+
`;
+
+ // Initialize elements.
+ this.hueInput = this.shadowRoot.getElementById( 'hue' );
+ this.saturationInput = this.shadowRoot.getElementById( 'saturation' );
+ this.lightnessInput = this.shadowRoot.getElementById( 'lightness' );
+ this.colorPreview = this.shadowRoot.getElementById( 'color-preview' );
+ this.rgbaDisplay = this.shadowRoot.getElementById( 'rgba-display' );
+
+ // Create a temporary canvas to read color values.
+ let tempCanvas = document.createElement( 'canvas' );
+ tempCanvas.height = 1;
+ tempCanvas.width = 1;
+ this.tempCanvasCTX = tempCanvas.getContext( '2d', { willReadFrequently: true } );
+
+ }
+
+
+ /**
+ * Handle attribute changes
+ *
+ * @param {string} name The name of the attribute that changed.
+ * @param {string} oldValue The old value of the attribute.
+ * @param {string} newValue The new value of the attribute.
+ * @return {void}
+ */
+ attributeChangedCallback( name, oldValue, newValue ) {
+
+ if ( name === 'value' && oldValue !== newValue ) {
+ this.setColor( newValue );
+ }
+
+ }
+
+
+ /**
+ * Getter for the attribute value.
+ *
+ * @return {string}
+ */
+ get value() {
+
+ return this._color;
+
+ }
+
+
+ /**
+ * Setter for the attribute value.
+ *
+ * @param {string} value The value to set.
+ */
+ set value( value ) {
+
+ this.setAttribute( 'color', value );
+
+ }
+
+
+ /**
+ * Handle the component being added to the DOM.
+ *
+ * @return {void}
+ */
+ connectedCallback() {
+
+ this.setupEventListeners();
+
+ const color = this.getAttribute( 'value' );
+ if ( !color ) {
+ this.setColor( 'green' );
+ }
+
+ }
+
+
+ /**
+ * Setup event listeners.
+ *
+ * @return {void}
+ */
+ setupEventListeners() {
+
+ const inputs = this.shadowRoot.querySelectorAll( 'input[type="range"]' );
+ inputs.forEach( input => input.addEventListener( 'input', () => this.maybeUpdateColor() ) );
+
+ }
+
+
+ /**
+ * Update the color after a short delay to prevent lag.
+ *
+ * @return {void}
+ */
+ maybeUpdateColor() {
+
+ clearTimeout( this._timeoutId );
+ this._timeoutId = setTimeout(
+ () => this.updateColor(),
+ 50
+ );
+
+ }
+
+
+ /**
+ * Update the color and the relevant sliders and html.
+ *
+ * @return {void}
+ */
+ updateColor() {
+
+ const hue = Math.round( this.hueInput.value );
+ const saturation = Math.round( this.saturationInput.value );
+ const lightness = Math.round( this.lightnessInput.value );
+ const hsla = [ hue, saturation, lightness ];
+
+ const rgba = this.HSLAToRGBA( hsla );
+
+ const hexString = this.rgbToHexString( rgba );
+
+ this._color = hexString;
+
+ this.dispatchEvent(
+ new CustomEvent(
+ 'change',
+ {
+ bubbles: true,
+ detail: {
+ hsla,
+ rgba,
+ hexString,
+ }
+ }
+ )
+ );
+
+ // Display RGBA string
+ this.rgbaDisplay.value = hexString;
+
+ // Update color and gradients
+ this.colorPreview.style.background = 'white';
+ this.colorPreview.style.backgroundImage = `
+ linear-gradient(to right, ${hexString}, ${hexString}),
+ linear-gradient(45deg, #ccc 25%, transparent 25%, transparent 75%, #ccc 75%, #ccc),
+ linear-gradient(45deg, #ccc 25%, transparent 25%, transparent 75%, #ccc 75%, #ccc)
+ `;
+ this.colorPreview.style.backgroundSize = '100% 100%, 10px 10px, 10px 10px';
+ this.colorPreview.style.backgroundPosition = '0 0, 0 0, 5px 5px';
+
+ // Update the hue slider gradient
+ this.hueInput.style.background = `linear-gradient(to right,
+ hsl(0, ${saturation}%, ${lightness}%) 0%,
+ hsl(60, ${saturation}%, ${lightness}%) 17%,
+ hsl(120, ${saturation}%, ${lightness}%) 33%,
+ hsl(180, ${saturation}%, ${lightness}%) 50%,
+ hsl(240, ${saturation}%, ${lightness}%) 67%,
+ hsl(300, ${saturation}%, ${lightness}%) 83%,
+ hsl(360, ${saturation}%, ${lightness}%) 100%
+ )`;
+
+ // Update the saturation slider gradient
+ this.saturationInput.style.background = `linear-gradient(to right,
+ hsl(${hue}, 0%, ${lightness}%) 0%,
+ hsl(${hue}, 100%, ${lightness}%) 100%
+ )`;
+
+ // Update the lightness slider gradient
+ this.lightnessInput.style.background = `linear-gradient(to right,
+ hsl(${hue}, ${saturation}%, 0%) 0%,
+ hsl(${hue}, ${saturation}%, 50%) 50%,
+ hsl(${hue}, ${saturation}%, 100%) 100%
+ )`;
+
+ }
+
+
+ /**
+ * Set the color of the picker.
+ *
+ * @param {string} color The color to set. It can be any valid CSS color value.
+ * @return {void}
+ */
+ setColor( color = 'hsla(60, 100%, 50%, 0.5)' ) {
+
+ const rgba = this.colorToRGBA( color );
+ const hsla = this.rgbToHSLA( rgba );
+
+ const [ hue, saturation, lightness ] = hsla;
+
+ // Set input values
+ this.hueInput.value = hue;
+ this.saturationInput.value = saturation;
+ this.lightnessInput.value = lightness;
+
+ this.updateColor();
+
+ }
+
+
+ /**
+ * Function to convert HSLA array to RGBA array.
+ *
+ * @param {array} hslaArray An array of HSLA values.
+ * @return {array} An array of RGBA values.
+ */
+ HSLAToRGBA( hslaArray ) {
+
+ const [ h, s, l] = hslaArray;
+
+ // Normalize HSL values
+ const normalizedH = h % 360 / 360;
+ const normalizedS = s / 100;
+ const normalizedL = l / 100;
+
+ // Helper function to convert hue to RGB
+ function hueToRGB( 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 ) * ( 2 / 3 - t ) * 6;
+ return p;
+ }
+
+ // Calculate RGB values
+ let r, g, b;
+
+ if ( normalizedS === 0 ) {
+ // If saturation is 0, the color is a shade of gray
+ r = g = b = normalizedL;
+ } else {
+ const q = normalizedL < 0.5 ? normalizedL * ( 1 + normalizedS ) : normalizedL + normalizedS - normalizedL * normalizedS;
+ const p = 2 * normalizedL - q;
+
+ r = hueToRGB( p, q, normalizedH + 1 / 3 );
+ g = hueToRGB( p, q, normalizedH );
+ b = hueToRGB( p, q, normalizedH - 1 / 3 );
+ }
+
+ // Convert RGB values to the range [0, 255]
+ return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+
+ }
+
+
+ /**
+ * Convert a colour string, whatever it contains, to an RGBA value.
+ *
+ * @param {string} color The color to convert.
+ * @return {array}
+ */
+ colorToRGBA( color ) {
+
+ const ctx = this.tempCanvasCTX;
+
+ // Clear canvas first.
+ // This ensures transparent colours don't add to each other.
+ ctx.clearRect( 0, 0, 1, 1 );
+
+ // Draw color.
+ ctx.fillStyle = color;
+ ctx.fillRect( 0, 0, 1, 1 );
+
+ // Read color.
+ let rgba = Array.from( ctx.getImageData( 0, 0, 1, 1 ).data );
+
+ // Convert alpha to range 0 -> 1
+ rgba[ 3 ] = 255;
+
+ return rgba;
+
+ }
+
+
+ /**
+ * Function to convert RGB array to hexa.
+ *
+ * @param {array} rgbArray An array of RGB values.
+ * @return {string} The hexa string.
+ */
+ rgbToHexString( rgbArray ) {
+
+ const [ r, g, b] = rgbArray;
+ return `#${r.toString( 16 ).padStart( 2, '0' )}${g.toString( 16 ).padStart( 2, '0' )}${b.toString( 16 ).padStart( 2, '0' )}`;
+
+ }
+
+
+ /**
+ * Function to convert RGB array to hsla.
+ *
+ * @param {array} rgbArray An array of RGB values.
+ * @return {string} The hsla string.
+ */
+ rgbToHSLString( rgbArray ) {
+
+ const hsla = this.rgbToHSLA( rgbArray );
+ return `hsla( ${hsla[ 0 ]}, ${hsla[ 1 ]} %, ${hsla[ 2 ]} %, ${hsla[ 3 ]} )`;
+
+ }
+
+
+ /**
+ * Function to convert RGB array to rgba.
+ *
+ * @param {array} rgbArray An array of RGB values.
+ * @return {string} The rgba string.
+ */
+ rgbToRGBString( rgbArray ) {
+
+ return `rgba( ${rgbArray.join( ',' )} )`;
+
+ }
+
+
+ /**
+ * Function to convert RGBA array to hsla.
+ *
+ * @param {array} rgbaArray An array of RGBA values.
+ * @return {array} An array of HSLA values.
+ */
+ rgbToHSLA( rgbaArray ) {
+
+ const [ r, g, b, a ] = rgbaArray;
+
+ // Normalize RGBA values to the range [0, 1]
+ const normalizedR = r / 255;
+ const normalizedG = g / 255;
+ const normalizedB = b / 255;
+
+ // Find the maximum and minimum values among the normalized RGB components
+ const max = Math.max( normalizedR, normalizedG, normalizedB );
+ const min = Math.min( normalizedR, normalizedG, normalizedB );
+
+ // Calculate lightness
+ const lightness = ( max + min ) / 2;
+
+ // Calculate saturation
+ let saturation = 0;
+ if ( max !== min ) {
+ saturation = ( max - min ) / ( 1 - Math.abs( 2 * lightness - 1 ) );
+ }
+
+ // Calculate hue
+ let hue;
+ if ( max === normalizedR ) {
+ hue = ( ( normalizedG - normalizedB ) / ( max - min ) ) % 6;
+ } else if ( max === normalizedG ) {
+ hue = ( ( normalizedB - normalizedR ) / ( max - min ) + 2 );
+ } else {
+ hue = ( ( normalizedR - normalizedG ) / ( max - min ) + 4 );
+ }
+
+ // Convert hue to degrees
+ hue *= 60;
+
+ if ( hue < 0 ) {
+ hue += 360;
+ }
+
+ return [ Math.round( hue ), Math.round( saturation * 100 ), Math.round( lightness * 100 ), a ];
+
+ }
+
+}
+
+customElements.define( 'color-picker', ColorPicker );
diff --git a/src/main/resources/META-INF/resources/vendor/dice-box/Dice.js b/src/main/resources/META-INF/resources/vendor/dice-box/Dice.js
new file mode 100644
index 0000000..54ccf98
--- /dev/null
+++ b/src/main/resources/META-INF/resources/vendor/dice-box/Dice.js
@@ -0,0 +1,33326 @@
+var bs = Object.defineProperty;
+var ys = (l, e, t) => e in l ? bs(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t;
+var Ut = (l, e, t) => (ys(l, typeof e != "symbol" ? e + "" : e, t), t);
+import { d as Ts } from "./dice-box.es.js";
+class Ms {
+ /**
+ * Create a new EventState
+ * @param mask defines the mask associated with this state
+ * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
+ * @param target defines the original target of the state
+ * @param currentTarget defines the current target of the state
+ */
+ constructor(e, t = !1, i, s) {
+ this.initialize(e, t, i, s);
+ }
+ /**
+ * Initialize the current event state
+ * @param mask defines the mask associated with this state
+ * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
+ * @param target defines the original target of the state
+ * @param currentTarget defines the current target of the state
+ * @returns the current event state
+ */
+ initialize(e, t = !1, i, s) {
+ return this.mask = e, this.skipNextObservers = t, this.target = i, this.currentTarget = s, this;
+ }
+}
+class Rs {
+ /**
+ * Creates a new observer
+ * @param callback defines the callback to call when the observer is notified
+ * @param mask defines the mask of the observer (used to filter notifications)
+ * @param scope defines the current scope used to restore the JS context
+ */
+ constructor(e, t, i = null) {
+ this.callback = e, this.mask = t, this.scope = i, this._willBeUnregistered = !1, this.unregisterOnNextCall = !1;
+ }
+}
+class w {
+ /**
+ * Create an observable from a Promise.
+ * @param promise a promise to observe for fulfillment.
+ * @param onErrorObservable an observable to notify if a promise was rejected.
+ * @returns the new Observable
+ */
+ static FromPromise(e, t) {
+ const i = new w();
+ return e.then((s) => {
+ i.notifyObservers(s);
+ }).catch((s) => {
+ if (t)
+ t.notifyObservers(s);
+ else
+ throw s;
+ }), i;
+ }
+ /**
+ * Gets the list of observers
+ * Note that observers that were recently deleted may still be present in the list because they are only really deleted on the next javascript tick!
+ */
+ get observers() {
+ return this._observers;
+ }
+ /**
+ * Creates a new observable
+ * @param onObserverAdded defines a callback to call when a new observer is added
+ * @param notifyIfTriggered If set to true the observable will notify when an observer was added if the observable was already triggered.
+ */
+ constructor(e, t = !1) {
+ this.notifyIfTriggered = t, this._observers = new Array(), this._numObserversMarkedAsDeleted = 0, this._hasNotified = !1, this._eventState = new Ms(0), e && (this._onObserverAdded = e);
+ }
+ /**
+ * Create a new Observer with the specified callback
+ * @param callback the callback that will be executed for that Observer
+ * @param mask the mask used to filter observers
+ * @param insertFirst if true the callback will be inserted at the first position, hence executed before the others ones. If false (default behavior) the callback will be inserted at the last position, executed after all the others already present.
+ * @param scope optional scope for the callback to be called from
+ * @param unregisterOnFirstCall defines if the observer as to be unregistered after the next notification
+ * @returns the new observer created for the callback
+ */
+ add(e, t = -1, i = !1, s = null, r = !1) {
+ if (!e)
+ return null;
+ const n = new Rs(e, t, s);
+ return n.unregisterOnNextCall = r, i ? this._observers.unshift(n) : this._observers.push(n), this._onObserverAdded && this._onObserverAdded(n), this._hasNotified && this.notifyIfTriggered && this._lastNotifiedValue !== void 0 && this.notifyObserver(n, this._lastNotifiedValue), n;
+ }
+ /**
+ * Create a new Observer with the specified callback and unregisters after the next notification
+ * @param callback the callback that will be executed for that Observer
+ * @returns the new observer created for the callback
+ */
+ addOnce(e) {
+ return this.add(e, void 0, void 0, void 0, !0);
+ }
+ /**
+ * Remove an Observer from the Observable object
+ * @param observer the instance of the Observer to remove
+ * @returns false if it doesn't belong to this Observable
+ */
+ remove(e) {
+ return e && this._observers.indexOf(e) !== -1 ? (this._deferUnregister(e), !0) : !1;
+ }
+ /**
+ * Remove a callback from the Observable object
+ * @param callback the callback to remove
+ * @param scope optional scope. If used only the callbacks with this scope will be removed
+ * @returns false if it doesn't belong to this Observable
+ */
+ removeCallback(e, t) {
+ for (let i = 0; i < this._observers.length; i++) {
+ const s = this._observers[i];
+ if (!s._willBeUnregistered && s.callback === e && (!t || t === s.scope))
+ return this._deferUnregister(s), !0;
+ }
+ return !1;
+ }
+ /**
+ * @internal
+ */
+ _deferUnregister(e) {
+ e._willBeUnregistered || (this._numObserversMarkedAsDeleted++, e.unregisterOnNextCall = !1, e._willBeUnregistered = !0, setTimeout(() => {
+ this._remove(e);
+ }, 0));
+ }
+ // This should only be called when not iterating over _observers to avoid callback skipping.
+ // Removes an observer from the _observer Array.
+ _remove(e, t = !0) {
+ if (!e)
+ return !1;
+ const i = this._observers.indexOf(e);
+ return i !== -1 ? (t && this._numObserversMarkedAsDeleted--, this._observers.splice(i, 1), !0) : !1;
+ }
+ /**
+ * Moves the observable to the top of the observer list making it get called first when notified
+ * @param observer the observer to move
+ */
+ makeObserverTopPriority(e) {
+ this._remove(e, !1), this._observers.unshift(e);
+ }
+ /**
+ * Moves the observable to the bottom of the observer list making it get called last when notified
+ * @param observer the observer to move
+ */
+ makeObserverBottomPriority(e) {
+ this._remove(e, !1), this._observers.push(e);
+ }
+ /**
+ * Notify all Observers by calling their respective callback with the given data
+ * Will return true if all observers were executed, false if an observer set skipNextObservers to true, then prevent the subsequent ones to execute
+ * @param eventData defines the data to send to all observers
+ * @param mask defines the mask of the current notification (observers with incompatible mask (ie mask & observer.mask === 0) will not be notified)
+ * @param target defines the original target of the state
+ * @param currentTarget defines the current target of the state
+ * @param userInfo defines any user info to send to observers
+ * @returns false if the complete observer chain was not processed (because one observer set the skipNextObservers to true)
+ */
+ notifyObservers(e, t = -1, i, s, r) {
+ if (this.notifyIfTriggered && (this._hasNotified = !0, this._lastNotifiedValue = e), !this._observers.length)
+ return !0;
+ const n = this._eventState;
+ n.mask = t, n.target = i, n.currentTarget = s, n.skipNextObservers = !1, n.lastReturnValue = e, n.userInfo = r;
+ for (const a of this._observers)
+ if (!a._willBeUnregistered && (a.mask & t && (a.unregisterOnNextCall && this._deferUnregister(a), a.scope ? n.lastReturnValue = a.callback.apply(a.scope, [e, n]) : n.lastReturnValue = a.callback(e, n)), n.skipNextObservers))
+ return !1;
+ return !0;
+ }
+ /**
+ * Notify a specific observer
+ * @param observer defines the observer to notify
+ * @param eventData defines the data to be sent to each callback
+ * @param mask is used to filter observers defaults to -1
+ */
+ notifyObserver(e, t, i = -1) {
+ if (this.notifyIfTriggered && (this._hasNotified = !0, this._lastNotifiedValue = t), e._willBeUnregistered)
+ return;
+ const s = this._eventState;
+ s.mask = i, s.skipNextObservers = !1, e.unregisterOnNextCall && this._deferUnregister(e), e.callback(t, s);
+ }
+ /**
+ * Gets a boolean indicating if the observable has at least one observer
+ * @returns true is the Observable has at least one Observer registered
+ */
+ hasObservers() {
+ return this._observers.length - this._numObserversMarkedAsDeleted > 0;
+ }
+ /**
+ * Clear the list of observers
+ */
+ clear() {
+ this._observers.length = 0, this._onObserverAdded = null, this._numObserversMarkedAsDeleted = 0, this.cleanLastNotifiedState();
+ }
+ /**
+ * Clean the last notified state - both the internal last value and the has-notified flag
+ */
+ cleanLastNotifiedState() {
+ this._hasNotified = !1, this._lastNotifiedValue = void 0;
+ }
+ /**
+ * Clone the current observable
+ * @returns a new observable
+ */
+ clone() {
+ const e = new w();
+ return e._observers = this._observers.slice(0), e;
+ }
+ /**
+ * Does this observable handles observer registered with a given mask
+ * @param mask defines the mask to be tested
+ * @returns whether or not one observer registered with the given mask is handled
+ **/
+ hasSpecificMask(e = -1) {
+ for (const t of this._observers)
+ if (t.mask & e || t.mask === e)
+ return !0;
+ return !1;
+ }
+}
+function Ie() {
+ return typeof window < "u";
+}
+function vi() {
+ return typeof navigator < "u";
+}
+function Wt() {
+ return typeof document < "u";
+}
+function Ii(l) {
+ let e = "", t = l.firstChild;
+ for (; t; )
+ t.nodeType === 3 && (e += t.textContent), t = t.nextSibling;
+ return e;
+}
+const Mi = {
+ /**
+ * Checks if the window object exists
+ * @returns true if the window object exists
+ */
+ IsWindowObjectExist: Ie,
+ /**
+ * Checks if the navigator object exists
+ * @returns true if the navigator object exists
+ */
+ IsNavigatorAvailable: vi,
+ /**
+ * Check if the document object exists
+ * @returns true if the document object exists
+ */
+ IsDocumentAvailable: Wt,
+ /**
+ * Extracts text content from a DOM element hierarchy
+ * @param element defines the root element
+ * @returns a string
+ */
+ GetDOMTextContent: Ii
+};
+class S {
+ static _CheckLimit(e, t) {
+ let i = S._LogLimitOutputs[e];
+ return i ? i.current++ : (i = { limit: t, current: 1 }, S._LogLimitOutputs[e] = i), i.current <= i.limit;
+ }
+ static _GenerateLimitMessage(e, t = 1) {
+ var i;
+ const s = S._LogLimitOutputs[e];
+ if (!s || !S.MessageLimitReached)
+ return;
+ const r = this._Levels[t];
+ s.current === s.limit && S[r.name](S.MessageLimitReached.replace(/%LIMIT%/g, "" + s.limit).replace(/%TYPE%/g, (i = r.name) !== null && i !== void 0 ? i : ""));
+ }
+ static _AddLogEntry(e) {
+ S._LogCache = e + S._LogCache, S.OnNewCacheEntry && S.OnNewCacheEntry(e);
+ }
+ static _FormatMessage(e) {
+ const t = (s) => s < 10 ? "0" + s : "" + s, i = /* @__PURE__ */ new Date();
+ return "[" + t(i.getHours()) + ":" + t(i.getMinutes()) + ":" + t(i.getSeconds()) + "]: " + e;
+ }
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ static _LogDisabled(e, t) {
+ }
+ static _LogEnabled(e = 1, t, i) {
+ if (i !== void 0 && !S._CheckLimit(t, i))
+ return;
+ const s = S._FormatMessage(t), r = this._Levels[e];
+ r.logFunc && r.logFunc("BJS - " + s);
+ const n = `
+
+
+
+
+
+
+
+ ${s}
`; + S._AddLogEntry(n), S._GenerateLimitMessage(t, e); + } + /** + * Gets current log cache (list of logs) + */ + static get LogCache() { + return S._LogCache; + } + /** + * Clears the log cache + */ + static ClearLogCache() { + S._LogCache = "", S._LogLimitOutputs = {}, S.errorsCount = 0; + } + /** + * Sets the current log level (MessageLogLevel / WarningLogLevel / ErrorLogLevel) + */ + static set LogLevels(e) { + S.Log = S._LogDisabled, S.Warn = S._LogDisabled, S.Error = S._LogDisabled, [S.MessageLogLevel, S.WarningLogLevel, S.ErrorLogLevel].forEach((t) => { + if ((e & t) === t) { + const i = this._Levels[t]; + S[i.name] = S._LogEnabled.bind(S, t); + } + }); + } +} +S.NoneLogLevel = 0; +S.MessageLogLevel = 1; +S.WarningLogLevel = 2; +S.ErrorLogLevel = 4; +S.AllLogLevel = 7; +S.MessageLimitReached = "Too many %TYPE%s (%LIMIT%), no more %TYPE%s will be reported for this message."; +S._LogCache = ""; +S._LogLimitOutputs = {}; +S._Levels = [ + {}, + { color: "white", logFunc: console.log, name: "Log" }, + { color: "orange", logFunc: console.warn, name: "Warn" }, + {}, + { color: "red", logFunc: console.error, name: "Error" } +]; +S.errorsCount = 0; +S.Log = S._LogEnabled.bind(S, S.MessageLogLevel); +S.Warn = S._LogEnabled.bind(S, S.WarningLogLevel); +S.Error = S._LogEnabled.bind(S, S.ErrorLogLevel); +const Ni = (l, e) => !l || l.getClassName && l.getClassName() === "Mesh" ? null : l.getClassName && l.getClassName() === "SubMesh" ? l.clone(e) : l.clone ? l.clone() : null; +function As(l) { + const e = []; + do + Object.getOwnPropertyNames(l).forEach(function(t) { + e.indexOf(t) === -1 && e.push(t); + }); + while (l = Object.getPrototypeOf(l)); + return e; +} +class Ci { + /** + * Tries to copy an object by duplicating every property + * @param source defines the source object + * @param destination defines the target object + * @param doNotCopyList defines a list of properties to avoid + * @param mustCopyList defines a list of properties to copy (even if they start with _) + */ + static DeepCopy(e, t, i, s) { + const r = As(e); + for (const n of r) { + if (n[0] === "_" && (!s || s.indexOf(n) === -1) || n.endsWith("Observable") || i && i.indexOf(n) !== -1) + continue; + const a = e[n], o = typeof a; + if (o !== "function") + try { + if (o === "object") + if (a instanceof Array) { + if (t[n] = [], a.length > 0) + if (typeof a[0] == "object") + for (let h = 0; h < a.length; h++) { + const c = Ni(a[h], t); + t[n].indexOf(c) === -1 && t[n].push(c); + } + else + t[n] = a.slice(0); + } else + t[n] = Ni(a, t); + else + t[n] = a; + } catch (h) { + S.Warn(h.message); + } + } + } +} +class Et { + /** + * Gets either window.performance.now() if supported or Date.now() else + */ + static get Now() { + return Mi.IsWindowObjectExist() && window.performance && window.performance.now ? window.performance.now() : Date.now(); + } +} +function Y(l) { + return `${l} needs to be imported before as it contains a side-effect required by your code.`; +} +function xs() { + return typeof _native < "u" && _native.XMLHttpRequest ? new _native.XMLHttpRequest() : new XMLHttpRequest(); +} +class He { + constructor() { + this._xhr = xs(), this._requestURL = ""; + } + _injectCustomRequestHeaders() { + if (!this._shouldSkipRequestModifications(this._requestURL)) + for (const e in He.CustomRequestHeaders) { + const t = He.CustomRequestHeaders[e]; + t && this._xhr.setRequestHeader(e, t); + } + } + _shouldSkipRequestModifications(e) { + return He.SkipRequestModificationForBabylonCDN && (e.includes("preview.babylonjs.com") || e.includes("cdn.babylonjs.com")); + } + /** + * Gets or sets a function to be called when loading progress changes + */ + get onprogress() { + return this._xhr.onprogress; + } + set onprogress(e) { + this._xhr.onprogress = e; + } + /** + * Returns client's state + */ + get readyState() { + return this._xhr.readyState; + } + /** + * Returns client's status + */ + get status() { + return this._xhr.status; + } + /** + * Returns client's status as a text + */ + get statusText() { + return this._xhr.statusText; + } + /** + * Returns client's response + */ + get response() { + return this._xhr.response; + } + /** + * Returns client's response url + */ + get responseURL() { + return this._xhr.responseURL; + } + /** + * Returns client's response as text + */ + get responseText() { + return this._xhr.responseText; + } + /** + * Gets or sets the expected response type + */ + get responseType() { + return this._xhr.responseType; + } + set responseType(e) { + this._xhr.responseType = e; + } + /** + * Gets or sets the timeout value in milliseconds + */ + get timeout() { + return this._xhr.timeout; + } + set timeout(e) { + this._xhr.timeout = e; + } + addEventListener(e, t, i) { + this._xhr.addEventListener(e, t, i); + } + removeEventListener(e, t, i) { + this._xhr.removeEventListener(e, t, i); + } + /** + * Cancels any network activity + */ + abort() { + this._xhr.abort(); + } + /** + * Initiates the request. The optional argument provides the request body. The argument is ignored if request method is GET or HEAD + * @param body defines an optional request body + */ + send(e) { + He.CustomRequestHeaders && this._injectCustomRequestHeaders(), this._xhr.send(e); + } + /** + * Sets the request method, request URL + * @param method defines the method to use (GET, POST, etc..) + * @param url defines the url to connect with + */ + open(e, t) { + for (const i of He.CustomRequestModifiers) { + if (this._shouldSkipRequestModifications(t)) + return; + i(this._xhr, t); + } + return t = t.replace("file:http:", "http:"), t = t.replace("file:https:", "https:"), this._requestURL = t, this._xhr.open(e, t, !0); + } + /** + * Sets the value of a request header. + * @param name The name of the header whose value is to be set + * @param value The value to set as the body of the header + */ + setRequestHeader(e, t) { + this._xhr.setRequestHeader(e, t); + } + /** + * Get the string containing the text of a particular header's value. + * @param name The name of the header + * @returns The string containing the text of the given header name + */ + getResponseHeader(e) { + return this._xhr.getResponseHeader(e); + } +} +He.CustomRequestHeaders = {}; +He.CustomRequestModifiers = new Array(); +He.SkipRequestModificationForBabylonCDN = !0; +class J { + /** + * Gets the latest created engine + */ + static get LastCreatedEngine() { + return this.Instances.length === 0 ? null : this.Instances[this.Instances.length - 1]; + } + /** + * Gets the latest created scene + */ + static get LastCreatedScene() { + return this._LastCreatedScene; + } +} +J.Instances = new Array(); +J.OnEnginesDisposedObservable = new w(); +J._LastCreatedScene = null; +J.UseFallbackTexture = !0; +J.FallbackTexture = ""; +class kt { +} +kt.FilesToLoad = {}; +class Es { + /** + * Function used to defines an exponential back off strategy + * @param maxRetries defines the maximum number of retries (3 by default) + * @param baseInterval defines the interval between retries + * @returns the strategy function to use + */ + static ExponentialBackoff(e = 3, t = 500) { + return (i, s, r) => s.status !== 0 || r >= e || i.indexOf("file:") !== -1 ? -1 : Math.pow(2, r) * t; + } +} +class Ot extends Error { +} +Ot._setPrototypeOf = Object.setPrototypeOf || ((l, e) => (l.__proto__ = e, l)); +const vt = { + // Mesh errors 0-999 + /** Invalid or empty mesh vertex positions. */ + MeshInvalidPositionsError: 0, + // Texture errors 1000-1999 + /** Unsupported texture found. */ + UnsupportedTextureError: 1e3, + // GLTFLoader errors 2000-2999 + /** Unexpected magic number found in GLTF file header. */ + GLTFLoaderUnexpectedMagicError: 2e3, + // SceneLoader errors 3000-3999 + /** SceneLoader generic error code. Ideally wraps the inner exception. */ + SceneLoaderError: 3e3, + // File related errors 4000-4999 + /** Load file error */ + LoadFileError: 4e3, + /** Request file error */ + RequestFileError: 4001, + /** Read file error */ + ReadFileError: 4002 +}; +class ct extends Ot { + /** + * Creates a new RuntimeError + * @param message defines the message of the error + * @param errorCode the error code + * @param innerError the error that caused the outer error + */ + constructor(e, t, i) { + super(e), this.errorCode = t, this.innerError = i, this.name = "RuntimeError", Ot._setPrototypeOf(this, ct.prototype); + } +} +const vs = (l) => { + const e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + let t = "", i, s, r, n, a, o, h, c = 0; + const u = ArrayBuffer.isView(l) ? new Uint8Array(l.buffer, l.byteOffset, l.byteLength) : new Uint8Array(l); + for (; c < u.length; ) + i = u[c++], s = c < u.length ? u[c++] : Number.NaN, r = c < u.length ? u[c++] : Number.NaN, n = i >> 2, a = (i & 3) << 4 | s >> 4, o = (s & 15) << 2 | r >> 6, h = r & 63, isNaN(s) ? o = h = 64 : isNaN(r) && (h = 64), t += e.charAt(n) + e.charAt(a) + e.charAt(o) + e.charAt(h); + return t; +}, ss = (l) => atob(l), Is = (l) => { + const e = ss(l), t = e.length, i = new Uint8Array(new ArrayBuffer(t)); + for (let s = 0; s < t; s++) + i[s] = e.charCodeAt(s); + return i.buffer; +}, Cs = "attribute", Ps = "varying"; +class Vt { + constructor() { + this.children = []; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + isValid(e) { + return !0; + } + process(e, t) { + var i, s, r, n, a, o; + let h = ""; + if (this.line) { + let c = this.line; + const u = t.processor; + if (u) { + u.lineProcessor && (c = u.lineProcessor(c, t.isFragment, t.processingContext)); + const d = (s = (i = t.processor) === null || i === void 0 ? void 0 : i.attributeKeywordName) !== null && s !== void 0 ? s : Cs, g = t.isFragment && (!((r = t.processor) === null || r === void 0) && r.varyingFragmentKeywordName) ? (n = t.processor) === null || n === void 0 ? void 0 : n.varyingFragmentKeywordName : !t.isFragment && (!((a = t.processor) === null || a === void 0) && a.varyingVertexKeywordName) ? (o = t.processor) === null || o === void 0 ? void 0 : o.varyingVertexKeywordName : Ps; + !t.isFragment && u.attributeProcessor && this.line.startsWith(d) ? c = u.attributeProcessor(this.line, e, t.processingContext) : u.varyingProcessor && this.line.startsWith(g) ? c = u.varyingProcessor(this.line, t.isFragment, e, t.processingContext) : u.uniformProcessor && u.uniformRegexp && u.uniformRegexp.test(this.line) ? t.lookForClosingBracketForUniformBuffer || (c = u.uniformProcessor(this.line, t.isFragment, e, t.processingContext)) : u.uniformBufferProcessor && u.uniformBufferRegexp && u.uniformBufferRegexp.test(this.line) ? t.lookForClosingBracketForUniformBuffer || (c = u.uniformBufferProcessor(this.line, t.isFragment, t.processingContext), t.lookForClosingBracketForUniformBuffer = !0) : u.textureProcessor && u.textureRegexp && u.textureRegexp.test(this.line) ? c = u.textureProcessor(this.line, t.isFragment, e, t.processingContext) : (u.uniformProcessor || u.uniformBufferProcessor) && this.line.startsWith("uniform") && !t.lookForClosingBracketForUniformBuffer && (/uniform\s+(?:(?:highp)?|(?:lowp)?)\s*(\S+)\s+(\S+)\s*;/.test(this.line) ? u.uniformProcessor && (c = u.uniformProcessor(this.line, t.isFragment, e, t.processingContext)) : u.uniformBufferProcessor && (c = u.uniformBufferProcessor(this.line, t.isFragment, t.processingContext), t.lookForClosingBracketForUniformBuffer = !0)), t.lookForClosingBracketForUniformBuffer && this.line.indexOf("}") !== -1 && (t.lookForClosingBracketForUniformBuffer = !1, u.endOfUniformBufferProcessor && (c = u.endOfUniformBufferProcessor(this.line, t.isFragment, t.processingContext))); + } + h += c + `\r +`; + } + return this.children.forEach((c) => { + h += c.process(e, t); + }), this.additionalDefineKey && (e[this.additionalDefineKey] = this.additionalDefineValue || "true"), h; + } +} +class Ss { + constructor() { + this._lines = []; + } + get currentLine() { + return this._lines[this.lineIndex]; + } + get canRead() { + return this.lineIndex < this._lines.length - 1; + } + set lines(e) { + this._lines.length = 0; + for (const t of e) { + if (t[0] === "#") { + this._lines.push(t); + continue; + } + if (t.trim().startsWith("//")) { + this._lines.push(t); + continue; + } + const i = t.split(";"); + for (let s = 0; s < i.length; s++) { + let r = i[s]; + r = r.trim(), r && this._lines.push(r + (s !== i.length - 1 ? ";" : "")); + } + } + } +} +class mi extends Vt { + process(e, t) { + for (let i = 0; i < this.children.length; i++) { + const s = this.children[i]; + if (s.isValid(e)) + return s.process(e, t); + } + return ""; + } +} +class Ds extends Vt { + isValid(e) { + return this.testExpression.isTrue(e); + } +} +class we { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + isTrue(e) { + return !0; + } + static postfixToInfix(e) { + const t = []; + for (const i of e) + if (we._OperatorPriority[i] === void 0) + t.push(i); + else { + const s = t[t.length - 1], r = t[t.length - 2]; + t.length -= 2, t.push(`(${r}${i}${s})`); + } + return t[t.length - 1]; + } + static infixToPostfix(e) { + const t = []; + let i = -1; + const s = () => { + h = h.trim(), h !== "" && (t.push(h), h = ""); + }, r = (c) => { + i < we._Stack.length - 1 && (we._Stack[++i] = c); + }, n = () => we._Stack[i], a = () => i === -1 ? "!!INVALID EXPRESSION!!" : we._Stack[i--]; + let o = 0, h = ""; + for (; o < e.length; ) { + const c = e.charAt(o), u = o < e.length - 1 ? e.substr(o, 2) : ""; + if (c === "(") + h = "", r(c); + else if (c === ")") { + for (s(); i !== -1 && n() !== "("; ) + t.push(a()); + a(); + } else if (we._OperatorPriority[u] > 1) { + for (s(); i !== -1 && we._OperatorPriority[n()] >= we._OperatorPriority[u]; ) + t.push(a()); + r(u), o++; + } else + h += c; + o++; + } + for (s(); i !== -1; ) + n() === "(" ? a() : t.push(a()); + return t; + } +} +we._OperatorPriority = { + ")": 0, + "(": 1, + "||": 2, + "&&": 3 +}; +we._Stack = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""]; +class Zt extends we { + constructor(e, t = !1) { + super(), this.define = e, this.not = t; + } + isTrue(e) { + let t = e[this.define] !== void 0; + return this.not && (t = !t), t; + } +} +class Fs extends we { + isTrue(e) { + return this.leftOperand.isTrue(e) || this.rightOperand.isTrue(e); + } +} +class ws extends we { + isTrue(e) { + return this.leftOperand.isTrue(e) && this.rightOperand.isTrue(e); + } +} +class Os extends we { + constructor(e, t, i) { + super(), this.define = e, this.operand = t, this.testValue = i; + } + isTrue(e) { + let t = e[this.define]; + t === void 0 && (t = this.define); + let i = !1; + const s = parseInt(t), r = parseInt(this.testValue); + switch (this.operand) { + case ">": + i = s > r; + break; + case "<": + i = s < r; + break; + case "<=": + i = s <= r; + break; + case ">=": + i = s >= r; + break; + case "==": + i = s === r; + break; + } + return i; + } +} +var Ce; +(function(l) { + l[l.GLSL = 0] = "GLSL", l[l.WGSL = 1] = "WGSL"; +})(Ce || (Ce = {})); +const Bs = /defined\s*?\((.+?)\)/g, bi = /defined\s*?\[(.+?)\]/g, ki = /#include\s?<(.+)>(\((.*)\))*(\[(.*)\])*/g; +class xt { + static Initialize(e) { + e.processor && e.processor.initializeShaders && e.processor.initializeShaders(e.processingContext); + } + static Process(e, t, i, s) { + var r; + !((r = t.processor) === null || r === void 0) && r.preProcessShaderCode && (e = t.processor.preProcessShaderCode(e, t.isFragment)), this._ProcessIncludes(e, t, (n) => { + t.processCodeAfterIncludes && (n = t.processCodeAfterIncludes(t.isFragment ? "fragment" : "vertex", n)); + const a = this._ProcessShaderConversion(n, t, s); + i(a, n); + }); + } + static PreProcess(e, t, i, s) { + var r; + !((r = t.processor) === null || r === void 0) && r.preProcessShaderCode && (e = t.processor.preProcessShaderCode(e, t.isFragment)), this._ProcessIncludes(e, t, (n) => { + t.processCodeAfterIncludes && (n = t.processCodeAfterIncludes(t.isFragment ? "fragment" : "vertex", n)); + const a = this._ApplyPreProcessing(n, t, s); + i(a, n); + }); + } + static Finalize(e, t, i) { + return !i.processor || !i.processor.finalizeShaders ? { vertexCode: e, fragmentCode: t } : i.processor.finalizeShaders(e, t, i.processingContext); + } + static _ProcessPrecision(e, t) { + var i; + if (!((i = t.processor) === null || i === void 0) && i.noPrecision) + return e; + const s = t.shouldUseHighPrecisionShader; + return e.indexOf("precision highp float") === -1 ? s ? e = `precision highp float; +` + e : e = `precision mediump float; +` + e : s || (e = e.replace("precision highp float", "precision mediump float")), e; + } + static _ExtractOperation(e) { + const i = /defined\((.+)\)/.exec(e); + if (i && i.length) + return new Zt(i[1].trim(), e[0] === "!"); + const s = ["==", ">=", "<=", "<", ">"]; + let r = "", n = 0; + for (r of s) + if (n = e.indexOf(r), n > -1) + break; + if (n === -1) + return new Zt(e); + const a = e.substring(0, n).trim(), o = e.substring(n + r.length).trim(); + return new Os(a, r, o); + } + static _BuildSubExpression(e) { + e = e.replace(Bs, "defined[$1]"); + const t = we.infixToPostfix(e), i = []; + for (const r of t) + if (r !== "||" && r !== "&&") + i.push(r); + else if (i.length >= 2) { + let n = i[i.length - 1], a = i[i.length - 2]; + i.length -= 2; + const o = r == "&&" ? new ws() : new Fs(); + typeof n == "string" && (n = n.replace(bi, "defined($1)")), typeof a == "string" && (a = a.replace(bi, "defined($1)")), o.leftOperand = typeof a == "string" ? this._ExtractOperation(a) : a, o.rightOperand = typeof n == "string" ? this._ExtractOperation(n) : n, i.push(o); + } + let s = i[i.length - 1]; + return typeof s == "string" && (s = s.replace(bi, "defined($1)")), typeof s == "string" ? this._ExtractOperation(s) : s; + } + static _BuildExpression(e, t) { + const i = new Ds(), s = e.substring(0, t); + let r = e.substring(t); + return r = r.substring(0, (r.indexOf("//") + 1 || r.length + 1) - 1).trim(), s === "#ifdef" ? i.testExpression = new Zt(r) : s === "#ifndef" ? i.testExpression = new Zt(r, !0) : i.testExpression = this._BuildSubExpression(r), i; + } + static _MoveCursorWithinIf(e, t, i) { + let s = e.currentLine; + for (; this._MoveCursor(e, i); ) { + s = e.currentLine; + const r = s.substring(0, 5).toLowerCase(); + if (r === "#else") { + const n = new Vt(); + t.children.push(n), this._MoveCursor(e, n); + return; + } else if (r === "#elif") { + const n = this._BuildExpression(s, 5); + t.children.push(n), i = n; + } + } + } + static _MoveCursor(e, t) { + for (; e.canRead; ) { + e.lineIndex++; + const i = e.currentLine, r = /(#ifdef)|(#else)|(#elif)|(#endif)|(#ifndef)|(#if)/.exec(i); + if (r && r.length) + switch (r[0]) { + case "#ifdef": { + const a = new mi(); + t.children.push(a); + const o = this._BuildExpression(i, 6); + a.children.push(o), this._MoveCursorWithinIf(e, a, o); + break; + } + case "#else": + case "#elif": + return !0; + case "#endif": + return !1; + case "#ifndef": { + const a = new mi(); + t.children.push(a); + const o = this._BuildExpression(i, 7); + a.children.push(o), this._MoveCursorWithinIf(e, a, o); + break; + } + case "#if": { + const a = new mi(), o = this._BuildExpression(i, 3); + t.children.push(a), a.children.push(o), this._MoveCursorWithinIf(e, a, o); + break; + } + } + else { + const n = new Vt(); + if (n.line = i, t.children.push(n), i[0] === "#" && i[1] === "d") { + const a = i.replace(";", "").split(" "); + n.additionalDefineKey = a[1], a.length === 3 && (n.additionalDefineValue = a[2]); + } + } + } + return !1; + } + static _EvaluatePreProcessors(e, t, i) { + const s = new Vt(), r = new Ss(); + return r.lineIndex = -1, r.lines = e.split(` +`), this._MoveCursor(r, s), s.process(t, i); + } + static _PreparePreProcessors(e, t) { + var i; + const s = e.defines, r = {}; + for (const n of s) { + const o = n.replace("#define", "").replace(";", "").trim().split(" "); + r[o[0]] = o.length > 1 ? o[1] : ""; + } + return ((i = e.processor) === null || i === void 0 ? void 0 : i.shaderLanguage) === Ce.GLSL && (r.GL_ES = "true"), r.__VERSION__ = e.version, r[e.platformName] = "true", t._getGlobalDefines(r), r; + } + static _ProcessShaderConversion(e, t, i) { + let s = this._ProcessPrecision(e, t); + if (!t.processor || t.processor.shaderLanguage === Ce.GLSL && s.indexOf("#version 3") !== -1 && (s = s.replace("#version 300 es", ""), !t.processor.parseGLES3)) + return s; + const r = t.defines, n = this._PreparePreProcessors(t, i); + return t.processor.preProcessor && (s = t.processor.preProcessor(s, r, t.isFragment, t.processingContext)), s = this._EvaluatePreProcessors(s, n, t), t.processor.postProcessor && (s = t.processor.postProcessor(s, r, t.isFragment, t.processingContext, i)), i._features.needShaderCodeInlining && (s = i.inlineShaderCode(s)), s; + } + static _ApplyPreProcessing(e, t, i) { + var s, r; + let n = e; + const a = t.defines, o = this._PreparePreProcessors(t, i); + return !((s = t.processor) === null || s === void 0) && s.preProcessor && (n = t.processor.preProcessor(n, a, t.isFragment, t.processingContext)), n = this._EvaluatePreProcessors(n, o, t), !((r = t.processor) === null || r === void 0) && r.postProcessor && (n = t.processor.postProcessor(n, a, t.isFragment, t.processingContext, i)), i._features.needShaderCodeInlining && (n = i.inlineShaderCode(n)), n; + } + static _ProcessIncludes(e, t, i) { + let s = ki.exec(e), r = new String(e), n = !1; + for (; s != null; ) { + let a = s[1]; + if (a.indexOf("__decl__") !== -1 && (a = a.replace(/__decl__/, ""), t.supportsUniformBuffers && (a = a.replace(/Vertex/, "Ubo"), a = a.replace(/Fragment/, "Ubo")), a = a + "Declaration"), t.includesShadersStore[a]) { + let o = t.includesShadersStore[a]; + if (s[2]) { + const h = s[3].split(","); + for (let c = 0; c < h.length; c += 2) { + const u = new RegExp(h[c], "g"), d = h[c + 1]; + o = o.replace(u, d); + } + } + if (s[4]) { + const h = s[5]; + if (h.indexOf("..") !== -1) { + const c = h.split(".."), u = parseInt(c[0]); + let d = parseInt(c[1]), g = o.slice(0); + o = "", isNaN(d) && (d = t.indexParameters[c[1]]); + for (let f = u; f < d; f++) + t.supportsUniformBuffers || (g = g.replace(/light\{X\}.(\w*)/g, (m, b) => b + "{X}")), o += g.replace(/\{X\}/g, f.toString()) + ` +`; + } else + t.supportsUniformBuffers || (o = o.replace(/light\{X\}.(\w*)/g, (c, u) => u + "{X}")), o = o.replace(/\{X\}/g, h); + } + r = r.replace(s[0], o), n = n || o.indexOf("#include<") >= 0 || o.indexOf("#include <") >= 0; + } else { + const o = t.shadersRepository + "ShadersInclude/" + a + ".fx"; + xt._FileToolsLoadFile(o, (h) => { + t.includesShadersStore[a] = h, this._ProcessIncludes(r, t, i); + }); + return; + } + s = ki.exec(e); + } + n ? this._ProcessIncludes(r.toString(), t, i) : i(r); + } + /** + * Loads a file from a url + * @param url url to load + * @param onSuccess callback called when the file successfully loads + * @param onProgress callback called while file is loading (if the server supports this mode) + * @param offlineProvider defines the offline provider for caching + * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer + * @param onError callback called when the file fails to load + * @returns a file request object + * @internal + */ + static _FileToolsLoadFile(e, t, i, s, r, n) { + throw Y("FileTools"); + } +} +class ge { + /** + * Gets the shaders repository path for a given shader language + * @param shaderLanguage the shader language + * @returns the path to the shaders repository + */ + static GetShadersRepository(e = Ce.GLSL) { + return e === Ce.GLSL ? ge.ShadersRepository : ge.ShadersRepositoryWGSL; + } + /** + * Gets the shaders store of a given shader language + * @param shaderLanguage the shader language + * @returns the shaders store + */ + static GetShadersStore(e = Ce.GLSL) { + return e === Ce.GLSL ? ge.ShadersStore : ge.ShadersStoreWGSL; + } + /** + * Gets the include shaders store of a given shader language + * @param shaderLanguage the shader language + * @returns the include shaders store + */ + static GetIncludesShadersStore(e = Ce.GLSL) { + return e === Ce.GLSL ? ge.IncludesShadersStore : ge.IncludesShadersStoreWGSL; + } +} +ge.ShadersRepository = "src/Shaders/"; +ge.ShadersStore = {}; +ge.IncludesShadersStore = {}; +ge.ShadersRepositoryWGSL = "src/ShadersWGSL/"; +ge.ShadersStoreWGSL = {}; +ge.IncludesShadersStoreWGSL = {}; +class Be { + /** + * Gets or sets the relative url used to load shaders if using the engine in non-minified mode + */ + static get ShadersRepository() { + return ge.ShadersRepository; + } + static set ShadersRepository(e) { + ge.ShadersRepository = e; + } + /** + * Observable that will be called when effect is bound. + */ + get onBindObservable() { + return this._onBindObservable || (this._onBindObservable = new w()), this._onBindObservable; + } + /** + * Instantiates an effect. + * An effect can be used to create/manage/execute vertex and fragment shaders. + * @param baseName Name of the effect. + * @param attributesNamesOrOptions List of attribute names that will be passed to the shader or set of all options to create the effect. + * @param uniformsNamesOrEngine List of uniform variable names that will be passed to the shader or the engine that will be used to render effect. + * @param samplers List of sampler variables that will be passed to the shader. + * @param engine Engine to be used to render the effect + * @param defines Define statements to be added to the shader. + * @param fallbacks Possible fallbacks for this effect to improve performance when needed. + * @param onCompiled Callback that will be called when the shader is compiled. + * @param onError Callback that will be called if an error occurs during shader compilation. + * @param indexParameters Parameters to be used with Babylons include syntax to iterate over an array (eg. {lights: 10}) + * @param key Effect Key identifying uniquely compiled shader variants + * @param shaderLanguage the language the shader is written in (default: GLSL) + */ + constructor(e, t, i, s = null, r, n = null, a = null, o = null, h = null, c, u = "", d = Ce.GLSL) { + var g, f, m; + this.name = null, this.defines = "", this.onCompiled = null, this.onError = null, this.onBind = null, this.uniqueId = 0, this.onCompileObservable = new w(), this.onErrorObservable = new w(), this._onBindObservable = null, this._wasPreviouslyReady = !1, this._forceRebindOnNextCall = !1, this._wasPreviouslyUsingInstances = null, this._isDisposed = !1, this._bonesComputationForcedToCPU = !1, this._uniformBuffersNames = {}, this._multiTarget = !1, this._samplers = {}, this._isReady = !1, this._compilationError = "", this._allFallbacksProcessed = !1, this._uniforms = {}, this._key = "", this._fallbacks = null, this._vertexSourceCodeOverride = "", this._fragmentSourceCodeOverride = "", this._transformFeedbackVaryings = null, this._pipelineContext = null, this._vertexSourceCode = "", this._fragmentSourceCode = "", this._vertexSourceCodeBeforeMigration = "", this._fragmentSourceCodeBeforeMigration = "", this._rawVertexSourceCode = "", this._rawFragmentSourceCode = "", this.name = e, this._key = u; + let b, T = null; + if (t.attributes) { + const D = t; + if (this._engine = i, this._attributesNames = D.attributes, this._uniformsNames = D.uniformsNames.concat(D.samplers), this._samplerList = D.samplers.slice(), this.defines = D.defines, this.onError = D.onError, this.onCompiled = D.onCompiled, this._fallbacks = D.fallbacks, this._indexParameters = D.indexParameters, this._transformFeedbackVaryings = D.transformFeedbackVaryings || null, this._multiTarget = !!D.multiTarget, this._shaderLanguage = (g = D.shaderLanguage) !== null && g !== void 0 ? g : Ce.GLSL, D.uniformBuffersNames) { + this._uniformBuffersNamesList = D.uniformBuffersNames.slice(); + for (let V = 0; V < D.uniformBuffersNames.length; V++) + this._uniformBuffersNames[D.uniformBuffersNames[V]] = V; + } + T = (f = D.processFinalCode) !== null && f !== void 0 ? f : null, b = (m = D.processCodeAfterIncludes) !== null && m !== void 0 ? m : void 0; + } else + this._engine = r, this.defines = n ?? "", this._uniformsNames = i.concat(s), this._samplerList = s ? s.slice() : [], this._attributesNames = t, this._uniformBuffersNamesList = [], this._shaderLanguage = d, this.onError = h, this.onCompiled = o, this._indexParameters = c, this._fallbacks = a; + this._attributeLocationByName = {}, this.uniqueId = Be._UniqueIdSeed++; + let M, v; + const A = Ie() ? this._engine.getHostDocument() : null; + e.vertexSource ? M = "source:" + e.vertexSource : e.vertexElement ? (M = A ? A.getElementById(e.vertexElement) : null, M || (M = e.vertexElement)) : M = e.vertex || e, e.fragmentSource ? v = "source:" + e.fragmentSource : e.fragmentElement ? (v = A ? A.getElementById(e.fragmentElement) : null, v || (v = e.fragmentElement)) : v = e.fragment || e, this._processingContext = this._engine._getShaderProcessingContext(this._shaderLanguage); + let E = { + defines: this.defines.split(` +`), + indexParameters: this._indexParameters, + isFragment: !1, + shouldUseHighPrecisionShader: this._engine._shouldUseHighPrecisionShader, + processor: this._engine._getShaderProcessor(this._shaderLanguage), + supportsUniformBuffers: this._engine.supportsUniformBuffers, + shadersRepository: ge.GetShadersRepository(this._shaderLanguage), + includesShadersStore: ge.GetIncludesShadersStore(this._shaderLanguage), + version: (this._engine.version * 100).toString(), + platformName: this._engine.shaderPlatformName, + processingContext: this._processingContext, + isNDCHalfZRange: this._engine.isNDCHalfZRange, + useReverseDepthBuffer: this._engine.useReverseDepthBuffer, + processCodeAfterIncludes: b + }; + const y = [void 0, void 0], x = () => { + if (y[0] && y[1]) { + E.isFragment = !0; + const [D, V] = y; + xt.Process(V, E, (W, ce) => { + this._fragmentSourceCodeBeforeMigration = ce, T && (W = T("fragment", W)); + const ee = xt.Finalize(D, W, E); + E = null, this._useFinalCode(ee.vertexCode, ee.fragmentCode, e); + }, this._engine); + } + }; + this._loadShader(M, "Vertex", "", (D) => { + xt.Initialize(E), xt.Process(D, E, (V, W) => { + this._rawVertexSourceCode = D, this._vertexSourceCodeBeforeMigration = W, T && (V = T("vertex", V)), y[0] = V, x(); + }, this._engine); + }), this._loadShader(v, "Fragment", "Pixel", (D) => { + this._rawFragmentSourceCode = D, y[1] = D, x(); + }); + } + _useFinalCode(e, t, i) { + if (i) { + const s = i.vertexElement || i.vertex || i.spectorName || i, r = i.fragmentElement || i.fragment || i.spectorName || i; + this._vertexSourceCode = (this._shaderLanguage === Ce.WGSL ? "//" : "") + "#define SHADER_NAME vertex:" + s + ` +` + e, this._fragmentSourceCode = (this._shaderLanguage === Ce.WGSL ? "//" : "") + "#define SHADER_NAME fragment:" + r + ` +` + t; + } else + this._vertexSourceCode = e, this._fragmentSourceCode = t; + this._prepareEffect(); + } + /** + * Unique key for this effect + */ + get key() { + return this._key; + } + /** + * If the effect has been compiled and prepared. + * @returns if the effect is compiled and prepared. + */ + isReady() { + try { + return this._isReadyInternal(); + } catch { + return !1; + } + } + _isReadyInternal() { + return this._isReady ? !0 : this._pipelineContext ? this._pipelineContext.isReady : !1; + } + /** + * The engine the effect was initialized with. + * @returns the engine. + */ + getEngine() { + return this._engine; + } + /** + * The pipeline context for this effect + * @returns the associated pipeline context + */ + getPipelineContext() { + return this._pipelineContext; + } + /** + * The set of names of attribute variables for the shader. + * @returns An array of attribute names. + */ + getAttributesNames() { + return this._attributesNames; + } + /** + * Returns the attribute at the given index. + * @param index The index of the attribute. + * @returns The location of the attribute. + */ + getAttributeLocation(e) { + return this._attributes[e]; + } + /** + * Returns the attribute based on the name of the variable. + * @param name of the attribute to look up. + * @returns the attribute location. + */ + getAttributeLocationByName(e) { + return this._attributeLocationByName[e]; + } + /** + * The number of attributes. + * @returns the number of attributes. + */ + getAttributesCount() { + return this._attributes.length; + } + /** + * Gets the index of a uniform variable. + * @param uniformName of the uniform to look up. + * @returns the index. + */ + getUniformIndex(e) { + return this._uniformsNames.indexOf(e); + } + /** + * Returns the attribute based on the name of the variable. + * @param uniformName of the uniform to look up. + * @returns the location of the uniform. + */ + getUniform(e) { + return this._uniforms[e]; + } + /** + * Returns an array of sampler variable names + * @returns The array of sampler variable names. + */ + getSamplers() { + return this._samplerList; + } + /** + * Returns an array of uniform variable names + * @returns The array of uniform variable names. + */ + getUniformNames() { + return this._uniformsNames; + } + /** + * Returns an array of uniform buffer variable names + * @returns The array of uniform buffer variable names. + */ + getUniformBuffersNames() { + return this._uniformBuffersNamesList; + } + /** + * Returns the index parameters used to create the effect + * @returns The index parameters object + */ + getIndexParameters() { + return this._indexParameters; + } + /** + * The error from the last compilation. + * @returns the error string. + */ + getCompilationError() { + return this._compilationError; + } + /** + * Gets a boolean indicating that all fallbacks were used during compilation + * @returns true if all fallbacks were used + */ + allFallbacksProcessed() { + return this._allFallbacksProcessed; + } + /** + * Adds a callback to the onCompiled observable and call the callback immediately if already ready. + * @param func The callback to be used. + */ + executeWhenCompiled(e) { + if (this.isReady()) { + e(this); + return; + } + this.onCompileObservable.add((t) => { + e(t); + }), (!this._pipelineContext || this._pipelineContext.isAsync) && setTimeout(() => { + this._checkIsReady(null); + }, 16); + } + _checkIsReady(e) { + try { + if (this._isReadyInternal()) + return; + } catch (t) { + this._processCompilationErrors(t, e); + return; + } + this._isDisposed || setTimeout(() => { + this._checkIsReady(e); + }, 16); + } + _loadShader(e, t, i, s) { + if (typeof HTMLElement < "u" && e instanceof HTMLElement) { + const a = Ii(e); + s(a); + return; + } + if (e.substr(0, 7) === "source:") { + s(e.substr(7)); + return; + } + if (e.substr(0, 7) === "base64:") { + const a = window.atob(e.substr(7)); + s(a); + return; + } + const r = ge.GetShadersStore(this._shaderLanguage); + if (r[e + t + "Shader"]) { + s(r[e + t + "Shader"]); + return; + } + if (i && r[e + i + "Shader"]) { + s(r[e + i + "Shader"]); + return; + } + let n; + e[0] === "." || e[0] === "/" || e.indexOf("http") > -1 ? n = e : n = ge.GetShadersRepository(this._shaderLanguage) + e, this._engine._loadFile(n + "." + t.toLowerCase() + ".fx", s); + } + /** + * Gets the vertex shader source code of this effect + * This is the final source code that will be compiled, after all the processing has been done (pre-processing applied, code injection/replacement, etc) + */ + get vertexSourceCode() { + var e, t; + return this._vertexSourceCodeOverride && this._fragmentSourceCodeOverride ? this._vertexSourceCodeOverride : (t = (e = this._pipelineContext) === null || e === void 0 ? void 0 : e._getVertexShaderCode()) !== null && t !== void 0 ? t : this._vertexSourceCode; + } + /** + * Gets the fragment shader source code of this effect + * This is the final source code that will be compiled, after all the processing has been done (pre-processing applied, code injection/replacement, etc) + */ + get fragmentSourceCode() { + var e, t; + return this._vertexSourceCodeOverride && this._fragmentSourceCodeOverride ? this._fragmentSourceCodeOverride : (t = (e = this._pipelineContext) === null || e === void 0 ? void 0 : e._getFragmentShaderCode()) !== null && t !== void 0 ? t : this._fragmentSourceCode; + } + /** + * Gets the vertex shader source code before migration. + * This is the source code after the include directives have been replaced by their contents but before the code is migrated, i.e. before ShaderProcess._ProcessShaderConversion is executed. + * This method is, among other things, responsible for parsing #if/#define directives as well as converting GLES2 syntax to GLES3 (in the case of WebGL). + */ + get vertexSourceCodeBeforeMigration() { + return this._vertexSourceCodeBeforeMigration; + } + /** + * Gets the fragment shader source code before migration. + * This is the source code after the include directives have been replaced by their contents but before the code is migrated, i.e. before ShaderProcess._ProcessShaderConversion is executed. + * This method is, among other things, responsible for parsing #if/#define directives as well as converting GLES2 syntax to GLES3 (in the case of WebGL). + */ + get fragmentSourceCodeBeforeMigration() { + return this._fragmentSourceCodeBeforeMigration; + } + /** + * Gets the vertex shader source code before it has been modified by any processing + */ + get rawVertexSourceCode() { + return this._rawVertexSourceCode; + } + /** + * Gets the fragment shader source code before it has been modified by any processing + */ + get rawFragmentSourceCode() { + return this._rawFragmentSourceCode; + } + /** + * Recompiles the webGL program + * @param vertexSourceCode The source code for the vertex shader. + * @param fragmentSourceCode The source code for the fragment shader. + * @param onCompiled Callback called when completed. + * @param onError Callback called on error. + * @internal + */ + _rebuildProgram(e, t, i, s) { + this._isReady = !1, this._vertexSourceCodeOverride = e, this._fragmentSourceCodeOverride = t, this.onError = (r, n) => { + s && s(n); + }, this.onCompiled = () => { + const r = this.getEngine().scenes; + if (r) + for (let n = 0; n < r.length; n++) + r[n].markAllMaterialsAsDirty(63); + this._pipelineContext._handlesSpectorRebuildCallback(i); + }, this._fallbacks = null, this._prepareEffect(); + } + /** + * Prepares the effect + * @internal + */ + _prepareEffect() { + const e = this._attributesNames, t = this.defines, i = this._pipelineContext; + this._isReady = !1; + try { + const s = this._engine; + this._pipelineContext = s.createPipelineContext(this._processingContext), this._pipelineContext._name = this._key; + const r = this._rebuildProgram.bind(this); + this._vertexSourceCodeOverride && this._fragmentSourceCodeOverride ? s._preparePipelineContext(this._pipelineContext, this._vertexSourceCodeOverride, this._fragmentSourceCodeOverride, !0, this._rawVertexSourceCode, this._rawFragmentSourceCode, r, null, this._transformFeedbackVaryings, this._key) : s._preparePipelineContext(this._pipelineContext, this._vertexSourceCode, this._fragmentSourceCode, !1, this._rawVertexSourceCode, this._rawFragmentSourceCode, r, t, this._transformFeedbackVaryings, this._key), s._executeWhenRenderingStateIsCompiled(this._pipelineContext, () => { + if (this._attributes = [], this._pipelineContext._fillEffectInformation(this, this._uniformBuffersNames, this._uniformsNames, this._uniforms, this._samplerList, this._samplers, e, this._attributes), e) + for (let n = 0; n < e.length; n++) { + const a = e[n]; + this._attributeLocationByName[a] = this._attributes[n]; + } + s.bindSamplers(this), this._compilationError = "", this._isReady = !0, this.onCompiled && this.onCompiled(this), this.onCompileObservable.notifyObservers(this), this.onCompileObservable.clear(), this._fallbacks && this._fallbacks.unBindMesh(), i && this.getEngine()._deletePipelineContext(i); + }), this._pipelineContext.isAsync && this._checkIsReady(i); + } catch (s) { + this._processCompilationErrors(s, i); + } + } + _getShaderCodeAndErrorLine(e, t, i) { + const s = i ? /FRAGMENT SHADER ERROR: 0:(\d+?):/ : /VERTEX SHADER ERROR: 0:(\d+?):/; + let r = null; + if (t && e) { + const n = t.match(s); + if (n && n.length === 2) { + const a = parseInt(n[1]), o = e.split(` +`, -1); + o.length >= a && (r = `Offending line [${a}] in ${i ? "fragment" : "vertex"} code: ${o[a - 1]}`); + } + } + return [e, r]; + } + _processCompilationErrors(e, t = null) { + var i, s, r; + this._compilationError = e.message; + const n = this._attributesNames, a = this._fallbacks; + if (S.Error("Unable to compile effect:"), S.Error("Uniforms: " + this._uniformsNames.map(function(h) { + return " " + h; + })), S.Error("Attributes: " + n.map(function(h) { + return " " + h; + })), S.Error(`Defines:\r +` + this.defines), Be.LogShaderCodeOnCompilationError) { + let h = null, c = null, u = null; + !((i = this._pipelineContext) === null || i === void 0) && i._getVertexShaderCode() && ([u, h] = this._getShaderCodeAndErrorLine(this._pipelineContext._getVertexShaderCode(), this._compilationError, !1), u && (S.Error("Vertex code:"), S.Error(u))), !((s = this._pipelineContext) === null || s === void 0) && s._getFragmentShaderCode() && ([u, c] = this._getShaderCodeAndErrorLine((r = this._pipelineContext) === null || r === void 0 ? void 0 : r._getFragmentShaderCode(), this._compilationError, !0), u && (S.Error("Fragment code:"), S.Error(u))), h && S.Error(h), c && S.Error(c); + } + S.Error("Error: " + this._compilationError); + const o = () => { + this.onError && this.onError(this, this._compilationError), this.onErrorObservable.notifyObservers(this); + }; + t && (this._pipelineContext = t, this._isReady = !0, o()), a ? (this._pipelineContext = null, a.hasMoreFallbacks ? (this._allFallbacksProcessed = !1, S.Error("Trying next fallback."), this.defines = a.reduce(this.defines, this), this._prepareEffect()) : (this._allFallbacksProcessed = !0, o(), this.onErrorObservable.clear(), this._fallbacks && this._fallbacks.unBindMesh())) : (this._allFallbacksProcessed = !0, t || o()); + } + /** + * Checks if the effect is supported. (Must be called after compilation) + */ + get isSupported() { + return this._compilationError === ""; + } + /** + * Binds a texture to the engine to be used as output of the shader. + * @param channel Name of the output variable. + * @param texture Texture to bind. + * @internal + */ + _bindTexture(e, t) { + this._engine._bindTexture(this._samplers[e], t, e); + } + /** + * Sets a texture on the engine to be used in the shader. + * @param channel Name of the sampler variable. + * @param texture Texture to set. + */ + setTexture(e, t) { + this._engine.setTexture(this._samplers[e], this._uniforms[e], t, e); + } + /** + * Sets a depth stencil texture from a render target on the engine to be used in the shader. + * @param channel Name of the sampler variable. + * @param texture Texture to set. + */ + setDepthStencilTexture(e, t) { + this._engine.setDepthStencilTexture(this._samplers[e], this._uniforms[e], t, e); + } + /** + * Sets an array of textures on the engine to be used in the shader. + * @param channel Name of the variable. + * @param textures Textures to set. + */ + setTextureArray(e, t) { + const i = e + "Ex"; + if (this._samplerList.indexOf(i + "0") === -1) { + const s = this._samplerList.indexOf(e); + for (let n = 1; n < t.length; n++) { + const a = i + (n - 1).toString(); + this._samplerList.splice(s + n, 0, a); + } + let r = 0; + for (const n of this._samplerList) + this._samplers[n] = r, r += 1; + } + this._engine.setTextureArray(this._samplers[e], this._uniforms[e], t, e); + } + /** + * Sets a texture to be the input of the specified post process. (To use the output, pass in the next post process in the pipeline) + * @param channel Name of the sampler variable. + * @param postProcess Post process to get the input texture from. + */ + setTextureFromPostProcess(e, t) { + this._engine.setTextureFromPostProcess(this._samplers[e], t, e); + } + /** + * (Warning! setTextureFromPostProcessOutput may be desired instead) + * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput) + * @param channel Name of the sampler variable. + * @param postProcess Post process to get the output texture from. + */ + setTextureFromPostProcessOutput(e, t) { + this._engine.setTextureFromPostProcessOutput(this._samplers[e], t, e); + } + /** + * Binds a buffer to a uniform. + * @param buffer Buffer to bind. + * @param name Name of the uniform variable to bind to. + */ + bindUniformBuffer(e, t) { + const i = this._uniformBuffersNames[t]; + i === void 0 || Be._BaseCache[i] === e && this._engine._features.useUBOBindingCache || (Be._BaseCache[i] = e, this._engine.bindUniformBufferBase(e, i, t)); + } + /** + * Binds block to a uniform. + * @param blockName Name of the block to bind. + * @param index Index to bind. + */ + bindUniformBlock(e, t) { + this._engine.bindUniformBlock(this._pipelineContext, e, t); + } + /** + * Sets an integer value on a uniform variable. + * @param uniformName Name of the variable. + * @param value Value to be set. + * @returns this effect. + */ + setInt(e, t) { + return this._pipelineContext.setInt(e, t), this; + } + /** + * Sets an int2 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First int in int2. + * @param y Second int in int2. + * @returns this effect. + */ + setInt2(e, t, i) { + return this._pipelineContext.setInt2(e, t, i), this; + } + /** + * Sets an int3 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First int in int3. + * @param y Second int in int3. + * @param z Third int in int3. + * @returns this effect. + */ + setInt3(e, t, i, s) { + return this._pipelineContext.setInt3(e, t, i, s), this; + } + /** + * Sets an int4 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First int in int4. + * @param y Second int in int4. + * @param z Third int in int4. + * @param w Fourth int in int4. + * @returns this effect. + */ + setInt4(e, t, i, s, r) { + return this._pipelineContext.setInt4(e, t, i, s, r), this; + } + /** + * Sets an int array on a uniform variable. + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setIntArray(e, t) { + return this._pipelineContext.setIntArray(e, t), this; + } + /** + * Sets an int array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setIntArray2(e, t) { + return this._pipelineContext.setIntArray2(e, t), this; + } + /** + * Sets an int array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setIntArray3(e, t) { + return this._pipelineContext.setIntArray3(e, t), this; + } + /** + * Sets an int array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setIntArray4(e, t) { + return this._pipelineContext.setIntArray4(e, t), this; + } + /** + * Sets an unsigned integer value on a uniform variable. + * @param uniformName Name of the variable. + * @param value Value to be set. + * @returns this effect. + */ + setUInt(e, t) { + return this._pipelineContext.setInt(e, t), this; + } + /** + * Sets an unsigned int2 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First unsigned int in uint2. + * @param y Second unsigned int in uint2. + * @returns this effect. + */ + setUInt2(e, t, i) { + return this._pipelineContext.setInt2(e, t, i), this; + } + /** + * Sets an unsigned int3 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First unsigned int in uint3. + * @param y Second unsigned int in uint3. + * @param z Third unsigned int in uint3. + * @returns this effect. + */ + setUInt3(e, t, i, s) { + return this._pipelineContext.setInt3(e, t, i, s), this; + } + /** + * Sets an unsigned int4 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First unsigned int in uint4. + * @param y Second unsigned int in uint4. + * @param z Third unsigned int in uint4. + * @param w Fourth unsigned int in uint4. + * @returns this effect. + */ + setUInt4(e, t, i, s, r) { + return this._pipelineContext.setInt4(e, t, i, s, r), this; + } + /** + * Sets an unsigned int array on a uniform variable. + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setUIntArray(e, t) { + return this._pipelineContext.setUIntArray(e, t), this; + } + /** + * Sets an unsigned int array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setUIntArray2(e, t) { + return this._pipelineContext.setUIntArray2(e, t), this; + } + /** + * Sets an unsigned int array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setUIntArray3(e, t) { + return this._pipelineContext.setUIntArray3(e, t), this; + } + /** + * Sets an unsigned int array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setUIntArray4(e, t) { + return this._pipelineContext.setUIntArray4(e, t), this; + } + /** + * Sets an float array on a uniform variable. + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setFloatArray(e, t) { + return this._pipelineContext.setArray(e, t), this; + } + /** + * Sets an float array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setFloatArray2(e, t) { + return this._pipelineContext.setArray2(e, t), this; + } + /** + * Sets an float array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setFloatArray3(e, t) { + return this._pipelineContext.setArray3(e, t), this; + } + /** + * Sets an float array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setFloatArray4(e, t) { + return this._pipelineContext.setArray4(e, t), this; + } + /** + * Sets an array on a uniform variable. + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setArray(e, t) { + return this._pipelineContext.setArray(e, t), this; + } + /** + * Sets an array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setArray2(e, t) { + return this._pipelineContext.setArray2(e, t), this; + } + /** + * Sets an array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setArray3(e, t) { + return this._pipelineContext.setArray3(e, t), this; + } + /** + * Sets an array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setArray4(e, t) { + return this._pipelineContext.setArray4(e, t), this; + } + /** + * Sets matrices on a uniform variable. + * @param uniformName Name of the variable. + * @param matrices matrices to be set. + * @returns this effect. + */ + setMatrices(e, t) { + return this._pipelineContext.setMatrices(e, t), this; + } + /** + * Sets matrix on a uniform variable. + * @param uniformName Name of the variable. + * @param matrix matrix to be set. + * @returns this effect. + */ + setMatrix(e, t) { + return this._pipelineContext.setMatrix(e, t), this; + } + /** + * Sets a 3x3 matrix on a uniform variable. (Specified as [1,2,3,4,5,6,7,8,9] will result in [1,2,3][4,5,6][7,8,9] matrix) + * @param uniformName Name of the variable. + * @param matrix matrix to be set. + * @returns this effect. + */ + setMatrix3x3(e, t) { + return this._pipelineContext.setMatrix3x3(e, t), this; + } + /** + * Sets a 2x2 matrix on a uniform variable. (Specified as [1,2,3,4] will result in [1,2][3,4] matrix) + * @param uniformName Name of the variable. + * @param matrix matrix to be set. + * @returns this effect. + */ + setMatrix2x2(e, t) { + return this._pipelineContext.setMatrix2x2(e, t), this; + } + /** + * Sets a float on a uniform variable. + * @param uniformName Name of the variable. + * @param value value to be set. + * @returns this effect. + */ + setFloat(e, t) { + return this._pipelineContext.setFloat(e, t), this; + } + /** + * Sets a boolean on a uniform variable. + * @param uniformName Name of the variable. + * @param bool value to be set. + * @returns this effect. + */ + setBool(e, t) { + return this._pipelineContext.setInt(e, t ? 1 : 0), this; + } + /** + * Sets a Vector2 on a uniform variable. + * @param uniformName Name of the variable. + * @param vector2 vector2 to be set. + * @returns this effect. + */ + setVector2(e, t) { + return this._pipelineContext.setVector2(e, t), this; + } + /** + * Sets a float2 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First float in float2. + * @param y Second float in float2. + * @returns this effect. + */ + setFloat2(e, t, i) { + return this._pipelineContext.setFloat2(e, t, i), this; + } + /** + * Sets a Vector3 on a uniform variable. + * @param uniformName Name of the variable. + * @param vector3 Value to be set. + * @returns this effect. + */ + setVector3(e, t) { + return this._pipelineContext.setVector3(e, t), this; + } + /** + * Sets a float3 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First float in float3. + * @param y Second float in float3. + * @param z Third float in float3. + * @returns this effect. + */ + setFloat3(e, t, i, s) { + return this._pipelineContext.setFloat3(e, t, i, s), this; + } + /** + * Sets a Vector4 on a uniform variable. + * @param uniformName Name of the variable. + * @param vector4 Value to be set. + * @returns this effect. + */ + setVector4(e, t) { + return this._pipelineContext.setVector4(e, t), this; + } + /** + * Sets a Quaternion on a uniform variable. + * @param uniformName Name of the variable. + * @param quaternion Value to be set. + * @returns this effect. + */ + setQuaternion(e, t) { + return this._pipelineContext.setQuaternion(e, t), this; + } + /** + * Sets a float4 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First float in float4. + * @param y Second float in float4. + * @param z Third float in float4. + * @param w Fourth float in float4. + * @returns this effect. + */ + setFloat4(e, t, i, s, r) { + return this._pipelineContext.setFloat4(e, t, i, s, r), this; + } + /** + * Sets a Color3 on a uniform variable. + * @param uniformName Name of the variable. + * @param color3 Value to be set. + * @returns this effect. + */ + setColor3(e, t) { + return this._pipelineContext.setColor3(e, t), this; + } + /** + * Sets a Color4 on a uniform variable. + * @param uniformName Name of the variable. + * @param color3 Value to be set. + * @param alpha Alpha value to be set. + * @returns this effect. + */ + setColor4(e, t, i) { + return this._pipelineContext.setColor4(e, t, i), this; + } + /** + * Sets a Color4 on a uniform variable + * @param uniformName defines the name of the variable + * @param color4 defines the value to be set + * @returns this effect. + */ + setDirectColor4(e, t) { + return this._pipelineContext.setDirectColor4(e, t), this; + } + /** + * Release all associated resources. + **/ + dispose() { + this._pipelineContext && this._pipelineContext.dispose(), this._engine._releaseEffect(this), this._isDisposed = !0; + } + /** + * This function will add a new shader to the shader store + * @param name the name of the shader + * @param pixelShader optional pixel shader content + * @param vertexShader optional vertex shader content + * @param shaderLanguage the language the shader is written in (default: GLSL) + */ + static RegisterShader(e, t, i, s = Ce.GLSL) { + t && (ge.GetShadersStore(s)[`${e}PixelShader`] = t), i && (ge.GetShadersStore(s)[`${e}VertexShader`] = i); + } + /** + * Resets the cache of effects. + */ + static ResetCache() { + Be._BaseCache = {}; + } +} +Be.LogShaderCodeOnCompilationError = !0; +Be._UniqueIdSeed = 0; +Be._BaseCache = {}; +Be.ShadersStore = ge.ShadersStore; +Be.IncludesShadersStore = ge.IncludesShadersStore; +class Ls { + /** + * Initializes the state. + * @param reset + */ + constructor(e = !0) { + this._isDepthTestDirty = !1, this._isDepthMaskDirty = !1, this._isDepthFuncDirty = !1, this._isCullFaceDirty = !1, this._isCullDirty = !1, this._isZOffsetDirty = !1, this._isFrontFaceDirty = !1, e && this.reset(); + } + get isDirty() { + return this._isDepthFuncDirty || this._isDepthTestDirty || this._isDepthMaskDirty || this._isCullFaceDirty || this._isCullDirty || this._isZOffsetDirty || this._isFrontFaceDirty; + } + get zOffset() { + return this._zOffset; + } + set zOffset(e) { + this._zOffset !== e && (this._zOffset = e, this._isZOffsetDirty = !0); + } + get zOffsetUnits() { + return this._zOffsetUnits; + } + set zOffsetUnits(e) { + this._zOffsetUnits !== e && (this._zOffsetUnits = e, this._isZOffsetDirty = !0); + } + get cullFace() { + return this._cullFace; + } + set cullFace(e) { + this._cullFace !== e && (this._cullFace = e, this._isCullFaceDirty = !0); + } + get cull() { + return this._cull; + } + set cull(e) { + this._cull !== e && (this._cull = e, this._isCullDirty = !0); + } + get depthFunc() { + return this._depthFunc; + } + set depthFunc(e) { + this._depthFunc !== e && (this._depthFunc = e, this._isDepthFuncDirty = !0); + } + get depthMask() { + return this._depthMask; + } + set depthMask(e) { + this._depthMask !== e && (this._depthMask = e, this._isDepthMaskDirty = !0); + } + get depthTest() { + return this._depthTest; + } + set depthTest(e) { + this._depthTest !== e && (this._depthTest = e, this._isDepthTestDirty = !0); + } + get frontFace() { + return this._frontFace; + } + set frontFace(e) { + this._frontFace !== e && (this._frontFace = e, this._isFrontFaceDirty = !0); + } + reset() { + this._depthMask = !0, this._depthTest = !0, this._depthFunc = null, this._cullFace = null, this._cull = null, this._zOffset = 0, this._zOffsetUnits = 0, this._frontFace = null, this._isDepthTestDirty = !0, this._isDepthMaskDirty = !0, this._isDepthFuncDirty = !1, this._isCullFaceDirty = !1, this._isCullDirty = !1, this._isZOffsetDirty = !0, this._isFrontFaceDirty = !1; + } + apply(e) { + this.isDirty && (this._isCullDirty && (this.cull ? e.enable(e.CULL_FACE) : e.disable(e.CULL_FACE), this._isCullDirty = !1), this._isCullFaceDirty && (e.cullFace(this.cullFace), this._isCullFaceDirty = !1), this._isDepthMaskDirty && (e.depthMask(this.depthMask), this._isDepthMaskDirty = !1), this._isDepthTestDirty && (this.depthTest ? e.enable(e.DEPTH_TEST) : e.disable(e.DEPTH_TEST), this._isDepthTestDirty = !1), this._isDepthFuncDirty && (e.depthFunc(this.depthFunc), this._isDepthFuncDirty = !1), this._isZOffsetDirty && (this.zOffset || this.zOffsetUnits ? (e.enable(e.POLYGON_OFFSET_FILL), e.polygonOffset(this.zOffset, this.zOffsetUnits)) : e.disable(e.POLYGON_OFFSET_FILL), this._isZOffsetDirty = !1), this._isFrontFaceDirty && (e.frontFace(this.frontFace), this._isFrontFaceDirty = !1)); + } +} +class lt { + constructor() { + this.reset(); + } + reset() { + this.enabled = !1, this.mask = 255, this.func = lt.ALWAYS, this.funcRef = 1, this.funcMask = 255, this.opStencilFail = lt.KEEP, this.opDepthFail = lt.KEEP, this.opStencilDepthPass = lt.REPLACE; + } + get stencilFunc() { + return this.func; + } + set stencilFunc(e) { + this.func = e; + } + get stencilFuncRef() { + return this.funcRef; + } + set stencilFuncRef(e) { + this.funcRef = e; + } + get stencilFuncMask() { + return this.funcMask; + } + set stencilFuncMask(e) { + this.funcMask = e; + } + get stencilOpStencilFail() { + return this.opStencilFail; + } + set stencilOpStencilFail(e) { + this.opStencilFail = e; + } + get stencilOpDepthFail() { + return this.opDepthFail; + } + set stencilOpDepthFail(e) { + this.opDepthFail = e; + } + get stencilOpStencilDepthPass() { + return this.opStencilDepthPass; + } + set stencilOpStencilDepthPass(e) { + this.opStencilDepthPass = e; + } + get stencilMask() { + return this.mask; + } + set stencilMask(e) { + this.mask = e; + } + get stencilTest() { + return this.enabled; + } + set stencilTest(e) { + this.enabled = e; + } +} +lt.ALWAYS = 519; +lt.KEEP = 7680; +lt.REPLACE = 7681; +class Us { + /** + * Initializes the state. + */ + constructor() { + this._blendFunctionParameters = new Array(4), this._blendEquationParameters = new Array(2), this._blendConstants = new Array(4), this._isBlendConstantsDirty = !1, this._alphaBlend = !1, this._isAlphaBlendDirty = !1, this._isBlendFunctionParametersDirty = !1, this._isBlendEquationParametersDirty = !1, this.reset(); + } + get isDirty() { + return this._isAlphaBlendDirty || this._isBlendFunctionParametersDirty || this._isBlendEquationParametersDirty; + } + get alphaBlend() { + return this._alphaBlend; + } + set alphaBlend(e) { + this._alphaBlend !== e && (this._alphaBlend = e, this._isAlphaBlendDirty = !0); + } + setAlphaBlendConstants(e, t, i, s) { + this._blendConstants[0] === e && this._blendConstants[1] === t && this._blendConstants[2] === i && this._blendConstants[3] === s || (this._blendConstants[0] = e, this._blendConstants[1] = t, this._blendConstants[2] = i, this._blendConstants[3] = s, this._isBlendConstantsDirty = !0); + } + setAlphaBlendFunctionParameters(e, t, i, s) { + this._blendFunctionParameters[0] === e && this._blendFunctionParameters[1] === t && this._blendFunctionParameters[2] === i && this._blendFunctionParameters[3] === s || (this._blendFunctionParameters[0] = e, this._blendFunctionParameters[1] = t, this._blendFunctionParameters[2] = i, this._blendFunctionParameters[3] = s, this._isBlendFunctionParametersDirty = !0); + } + setAlphaEquationParameters(e, t) { + this._blendEquationParameters[0] === e && this._blendEquationParameters[1] === t || (this._blendEquationParameters[0] = e, this._blendEquationParameters[1] = t, this._isBlendEquationParametersDirty = !0); + } + reset() { + this._alphaBlend = !1, this._blendFunctionParameters[0] = null, this._blendFunctionParameters[1] = null, this._blendFunctionParameters[2] = null, this._blendFunctionParameters[3] = null, this._blendEquationParameters[0] = null, this._blendEquationParameters[1] = null, this._blendConstants[0] = null, this._blendConstants[1] = null, this._blendConstants[2] = null, this._blendConstants[3] = null, this._isAlphaBlendDirty = !0, this._isBlendFunctionParametersDirty = !1, this._isBlendEquationParametersDirty = !1, this._isBlendConstantsDirty = !1; + } + apply(e) { + this.isDirty && (this._isAlphaBlendDirty && (this._alphaBlend ? e.enable(e.BLEND) : e.disable(e.BLEND), this._isAlphaBlendDirty = !1), this._isBlendFunctionParametersDirty && (e.blendFuncSeparate(this._blendFunctionParameters[0], this._blendFunctionParameters[1], this._blendFunctionParameters[2], this._blendFunctionParameters[3]), this._isBlendFunctionParametersDirty = !1), this._isBlendEquationParametersDirty && (e.blendEquationSeparate(this._blendEquationParameters[0], this._blendEquationParameters[1]), this._isBlendEquationParametersDirty = !1), this._isBlendConstantsDirty && (e.blendColor(this._blendConstants[0], this._blendConstants[1], this._blendConstants[2], this._blendConstants[3]), this._isBlendConstantsDirty = !1)); + } +} +class Ns { + /** + * | Value | Type | Description | + * | ----- | ------------------ | ----------- | + * | 0 | CLAMP_ADDRESSMODE | | + * | 1 | WRAP_ADDRESSMODE | | + * | 2 | MIRROR_ADDRESSMODE | | + */ + get wrapU() { + return this._cachedWrapU; + } + set wrapU(e) { + this._cachedWrapU = e; + } + /** + * | Value | Type | Description | + * | ----- | ------------------ | ----------- | + * | 0 | CLAMP_ADDRESSMODE | | + * | 1 | WRAP_ADDRESSMODE | | + * | 2 | MIRROR_ADDRESSMODE | | + */ + get wrapV() { + return this._cachedWrapV; + } + set wrapV(e) { + this._cachedWrapV = e; + } + /** + * | Value | Type | Description | + * | ----- | ------------------ | ----------- | + * | 0 | CLAMP_ADDRESSMODE | | + * | 1 | WRAP_ADDRESSMODE | | + * | 2 | MIRROR_ADDRESSMODE | | + */ + get wrapR() { + return this._cachedWrapR; + } + set wrapR(e) { + this._cachedWrapR = e; + } + /** + * With compliant hardware and browser (supporting anisotropic filtering) + * this defines the level of anisotropic filtering in the texture. + * The higher the better but the slower. + */ + get anisotropicFilteringLevel() { + return this._cachedAnisotropicFilteringLevel; + } + set anisotropicFilteringLevel(e) { + this._cachedAnisotropicFilteringLevel = e; + } + /** + * Gets or sets the comparison function (513, 514, etc). Set 0 to not use a comparison function + */ + get comparisonFunction() { + return this._comparisonFunction; + } + set comparisonFunction(e) { + this._comparisonFunction = e; + } + /** + * Indicates to use the mip maps (if available on the texture). + * Thanks to this flag, you can instruct the sampler to not sample the mipmaps even if they exist (and if the sampling mode is set to a value that normally samples the mipmaps!) + */ + get useMipMaps() { + return this._useMipMaps; + } + set useMipMaps(e) { + this._useMipMaps = e; + } + /** + * Creates a Sampler instance + */ + constructor() { + this.samplingMode = -1, this._useMipMaps = !0, this._cachedWrapU = null, this._cachedWrapV = null, this._cachedWrapR = null, this._cachedAnisotropicFilteringLevel = null, this._comparisonFunction = 0; + } + /** + * Sets all the parameters of the sampler + * @param wrapU u address mode (default: TEXTURE_WRAP_ADDRESSMODE) + * @param wrapV v address mode (default: TEXTURE_WRAP_ADDRESSMODE) + * @param wrapR r address mode (default: TEXTURE_WRAP_ADDRESSMODE) + * @param anisotropicFilteringLevel anisotropic level (default: 1) + * @param samplingMode sampling mode (default: 2) + * @param comparisonFunction comparison function (default: 0 - no comparison function) + * @returns the current sampler instance + */ + setParameters(e = 1, t = 1, i = 1, s = 1, r = 2, n = 0) { + return this._cachedWrapU = e, this._cachedWrapV = t, this._cachedWrapR = i, this._cachedAnisotropicFilteringLevel = s, this.samplingMode = r, this._comparisonFunction = n, this; + } + /** + * Compares this sampler with another one + * @param other sampler to compare with + * @returns true if the samplers have the same parametres, else false + */ + compareSampler(e) { + return this._cachedWrapU === e._cachedWrapU && this._cachedWrapV === e._cachedWrapV && this._cachedWrapR === e._cachedWrapR && this._cachedAnisotropicFilteringLevel === e._cachedAnisotropicFilteringLevel && this.samplingMode === e.samplingMode && this._comparisonFunction === e._comparisonFunction && this._useMipMaps === e._useMipMaps; + } +} +var De; +(function(l) { + l[l.Unknown = 0] = "Unknown", l[l.Url = 1] = "Url", l[l.Temp = 2] = "Temp", l[l.Raw = 3] = "Raw", l[l.Dynamic = 4] = "Dynamic", l[l.RenderTarget = 5] = "RenderTarget", l[l.MultiRenderTarget = 6] = "MultiRenderTarget", l[l.Cube = 7] = "Cube", l[l.CubeRaw = 8] = "CubeRaw", l[l.CubePrefiltered = 9] = "CubePrefiltered", l[l.Raw3D = 10] = "Raw3D", l[l.Raw2DArray = 11] = "Raw2DArray", l[l.DepthStencil = 12] = "DepthStencil", l[l.CubeRawRGBD = 13] = "CubeRawRGBD", l[l.Depth = 14] = "Depth"; +})(De || (De = {})); +class It extends Ns { + /** + * Gets a boolean indicating if the texture uses mipmaps + * TODO implements useMipMaps as a separate setting from generateMipMaps + */ + get useMipMaps() { + return this.generateMipMaps; + } + set useMipMaps(e) { + this.generateMipMaps = e; + } + /** Gets the unique id of the internal texture */ + get uniqueId() { + return this._uniqueId; + } + /** @internal */ + _setUniqueId(e) { + this._uniqueId = e; + } + /** + * Gets the Engine the texture belongs to. + * @returns The babylon engine + */ + getEngine() { + return this._engine; + } + /** + * Gets the data source type of the texture + */ + get source() { + return this._source; + } + /** + * Creates a new InternalTexture + * @param engine defines the engine to use + * @param source defines the type of data that will be used + * @param delayAllocation if the texture allocation should be delayed (default: false) + */ + constructor(e, t, i = !1) { + super(), this.isReady = !1, this.isCube = !1, this.is3D = !1, this.is2DArray = !1, this.isMultiview = !1, this.url = "", this.generateMipMaps = !1, this.samples = 0, this.type = -1, this.format = -1, this.onLoadedObservable = new w(), this.onErrorObservable = new w(), this.onRebuildCallback = null, this.width = 0, this.height = 0, this.depth = 0, this.baseWidth = 0, this.baseHeight = 0, this.baseDepth = 0, this.invertY = !1, this._invertVScale = !1, this._associatedChannel = -1, this._source = De.Unknown, this._buffer = null, this._bufferView = null, this._bufferViewArray = null, this._bufferViewArrayArray = null, this._size = 0, this._extension = "", this._files = null, this._workingCanvas = null, this._workingContext = null, this._cachedCoordinatesMode = null, this._isDisabled = !1, this._compression = null, this._sphericalPolynomial = null, this._sphericalPolynomialPromise = null, this._sphericalPolynomialComputed = !1, this._lodGenerationScale = 0, this._lodGenerationOffset = 0, this._useSRGBBuffer = !1, this._lodTextureHigh = null, this._lodTextureMid = null, this._lodTextureLow = null, this._isRGBD = !1, this._linearSpecularLOD = !1, this._irradianceTexture = null, this._hardwareTexture = null, this._maxLodLevel = null, this._references = 1, this._gammaSpace = null, this._engine = e, this._source = t, this._uniqueId = It._Counter++, i || (this._hardwareTexture = e._createHardwareTexture()); + } + /** + * Increments the number of references (ie. the number of Texture that point to it) + */ + incrementReferences() { + this._references++; + } + /** + * Change the size of the texture (not the size of the content) + * @param width defines the new width + * @param height defines the new height + * @param depth defines the new depth (1 by default) + */ + updateSize(e, t, i = 1) { + this._engine.updateTextureDimensions(this, e, t, i), this.width = e, this.height = t, this.depth = i, this.baseWidth = e, this.baseHeight = t, this.baseDepth = i, this._size = e * t * i; + } + /** @internal */ + _rebuild() { + var e; + if (this.isReady = !1, this._cachedCoordinatesMode = null, this._cachedWrapU = null, this._cachedWrapV = null, this._cachedWrapR = null, this._cachedAnisotropicFilteringLevel = null, this.onRebuildCallback) { + const i = this.onRebuildCallback(this), s = (r) => { + r._swapAndDie(this, !1), this.isReady = i.isReady; + }; + i.isAsync ? i.proxy.then(s) : s(i.proxy); + return; + } + let t; + switch (this.source) { + case De.Temp: + break; + case De.Url: + t = this._engine.createTexture( + (e = this._originalUrl) !== null && e !== void 0 ? e : this.url, + !this.generateMipMaps, + this.invertY, + null, + this.samplingMode, + // Do not use Proxy here as it could be fully synchronous + // and proxy would be undefined. + (i) => { + i._swapAndDie(this, !1), this.isReady = !0; + }, + null, + this._buffer, + void 0, + this.format, + this._extension, + void 0, + void 0, + void 0, + this._useSRGBBuffer + ); + return; + case De.Raw: + t = this._engine.createRawTexture(this._bufferView, this.baseWidth, this.baseHeight, this.format, this.generateMipMaps, this.invertY, this.samplingMode, this._compression, this.type, void 0, this._useSRGBBuffer), t._swapAndDie(this, !1), this.isReady = !0; + break; + case De.Raw3D: + t = this._engine.createRawTexture3D(this._bufferView, this.baseWidth, this.baseHeight, this.baseDepth, this.format, this.generateMipMaps, this.invertY, this.samplingMode, this._compression, this.type), t._swapAndDie(this, !1), this.isReady = !0; + break; + case De.Raw2DArray: + t = this._engine.createRawTexture2DArray(this._bufferView, this.baseWidth, this.baseHeight, this.baseDepth, this.format, this.generateMipMaps, this.invertY, this.samplingMode, this._compression, this.type), t._swapAndDie(this, !1), this.isReady = !0; + break; + case De.Dynamic: + t = this._engine.createDynamicTexture(this.baseWidth, this.baseHeight, this.generateMipMaps, this.samplingMode), t._swapAndDie(this, !1), this._engine.updateDynamicTexture(this, this._engine.getRenderingCanvas(), this.invertY, void 0, void 0, !0); + break; + case De.Cube: + t = this._engine.createCubeTexture(this.url, null, this._files, !this.generateMipMaps, () => { + t._swapAndDie(this, !1), this.isReady = !0; + }, null, this.format, this._extension, !1, 0, 0, null, void 0, this._useSRGBBuffer); + return; + case De.CubeRaw: + t = this._engine.createRawCubeTexture(this._bufferViewArray, this.width, this.format, this.type, this.generateMipMaps, this.invertY, this.samplingMode, this._compression), t._swapAndDie(this, !1), this.isReady = !0; + break; + case De.CubeRawRGBD: + return; + case De.CubePrefiltered: + t = this._engine.createPrefilteredCubeTexture(this.url, null, this._lodGenerationScale, this._lodGenerationOffset, (i) => { + i && i._swapAndDie(this, !1), this.isReady = !0; + }, null, this.format, this._extension), t._sphericalPolynomial = this._sphericalPolynomial; + return; + } + } + /** + * @internal + */ + _swapAndDie(e, t = !0) { + var i; + (i = this._hardwareTexture) === null || i === void 0 || i.setUsage(e._source, this.generateMipMaps, this.isCube, this.width, this.height), e._hardwareTexture = this._hardwareTexture, t && (e._isRGBD = this._isRGBD), this._lodTextureHigh && (e._lodTextureHigh && e._lodTextureHigh.dispose(), e._lodTextureHigh = this._lodTextureHigh), this._lodTextureMid && (e._lodTextureMid && e._lodTextureMid.dispose(), e._lodTextureMid = this._lodTextureMid), this._lodTextureLow && (e._lodTextureLow && e._lodTextureLow.dispose(), e._lodTextureLow = this._lodTextureLow), this._irradianceTexture && (e._irradianceTexture && e._irradianceTexture.dispose(), e._irradianceTexture = this._irradianceTexture); + const s = this._engine.getLoadedTexturesCache(); + let r = s.indexOf(this); + r !== -1 && s.splice(r, 1), r = s.indexOf(e), r === -1 && s.push(e); + } + /** + * Dispose the current allocated resources + */ + dispose() { + this._references--, this.onLoadedObservable.clear(), this.onErrorObservable.clear(), this._references === 0 && (this._engine._releaseTexture(this), this._hardwareTexture = null); + } +} +It._Counter = 0; +class ks { + constructor() { + this.shaderLanguage = Ce.GLSL; + } + postProcessor(e, t, i, s, r) { + if (!r.getCaps().drawBuffersExtension) { + const n = /#extension.+GL_EXT_draw_buffers.+(enable|require)/g; + e = e.replace(n, ""); + } + return e; + } +} +class Vs { + constructor() { + this.shaderLanguage = Ce.GLSL; + } + attributeProcessor(e) { + return e.replace("attribute", "in"); + } + varyingProcessor(e, t) { + return e.replace("varying", t ? "in" : "out"); + } + postProcessor(e, t, i) { + const s = e.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1, r = /#extension.+(GL_OVR_multiview2|GL_OES_standard_derivatives|GL_EXT_shader_texture_lod|GL_EXT_frag_depth|GL_EXT_draw_buffers).+(enable|require)/g; + if (e = e.replace(r, ""), e = e.replace(/texture2D\s*\(/g, "texture("), i) + e = e.replace(/texture2DLodEXT\s*\(/g, "textureLod("), e = e.replace(/textureCubeLodEXT\s*\(/g, "textureLod("), e = e.replace(/textureCube\s*\(/g, "texture("), e = e.replace(/gl_FragDepthEXT/g, "gl_FragDepth"), e = e.replace(/gl_FragColor/g, "glFragColor"), e = e.replace(/gl_FragData/g, "glFragData"), e = e.replace(/void\s+?main\s*\(/g, (s ? "" : `layout(location = 0) out vec4 glFragColor; +`) + "void main("); + else if (t.indexOf("#define MULTIVIEW") !== -1) + return `#extension GL_OVR_multiview2 : require +layout (num_views = 2) in; +` + e; + return e; + } +} +class Kt { + /** + * Gets the underlying buffer + */ + get underlyingResource() { + return null; + } + /** + * Constructs the buffer + */ + constructor() { + this.references = 0, this.capacity = 0, this.is32Bits = !1, this.uniqueId = Kt._Counter++; + } +} +Kt._Counter = 0; +class Gt extends Kt { + constructor(e) { + super(), this._buffer = e; + } + get underlyingResource() { + return this._buffer; + } +} +class Ws { + constructor() { + this._valueCache = {}, this.vertexCompilationError = null, this.fragmentCompilationError = null, this.programLinkError = null, this.programValidationError = null; + } + get isAsync() { + return this.isParallelCompiled; + } + get isReady() { + return this.program ? this.isParallelCompiled ? this.engine._isRenderingStateCompiled(this) : !0 : !1; + } + _handlesSpectorRebuildCallback(e) { + e && this.program && e(this.program); + } + _fillEffectInformation(e, t, i, s, r, n, a, o) { + const h = this.engine; + if (h.supportsUniformBuffers) + for (const d in t) + e.bindUniformBlock(d, t[d]); + this.engine.getUniforms(this, i).forEach((d, g) => { + s[i[g]] = d; + }), this._uniforms = s; + let u; + for (u = 0; u < r.length; u++) + e.getUniform(r[u]) == null && (r.splice(u, 1), u--); + r.forEach((d, g) => { + n[d] = g; + }); + for (const d of h.getAttributes(this, a)) + o.push(d); + } + /** + * Release all associated resources. + **/ + dispose() { + this._uniforms = {}; + } + /** + * @internal + */ + _cacheMatrix(e, t) { + const i = this._valueCache[e], s = t.updateFlag; + return i !== void 0 && i === s ? !1 : (this._valueCache[e] = s, !0); + } + /** + * @internal + */ + _cacheFloat2(e, t, i) { + let s = this._valueCache[e]; + if (!s || s.length !== 2) + return s = [t, i], this._valueCache[e] = s, !0; + let r = !1; + return s[0] !== t && (s[0] = t, r = !0), s[1] !== i && (s[1] = i, r = !0), r; + } + /** + * @internal + */ + _cacheFloat3(e, t, i, s) { + let r = this._valueCache[e]; + if (!r || r.length !== 3) + return r = [t, i, s], this._valueCache[e] = r, !0; + let n = !1; + return r[0] !== t && (r[0] = t, n = !0), r[1] !== i && (r[1] = i, n = !0), r[2] !== s && (r[2] = s, n = !0), n; + } + /** + * @internal + */ + _cacheFloat4(e, t, i, s, r) { + let n = this._valueCache[e]; + if (!n || n.length !== 4) + return n = [t, i, s, r], this._valueCache[e] = n, !0; + let a = !1; + return n[0] !== t && (n[0] = t, a = !0), n[1] !== i && (n[1] = i, a = !0), n[2] !== s && (n[2] = s, a = !0), n[3] !== r && (n[3] = r, a = !0), a; + } + /** + * Sets an integer value on a uniform variable. + * @param uniformName Name of the variable. + * @param value Value to be set. + */ + setInt(e, t) { + const i = this._valueCache[e]; + i !== void 0 && i === t || this.engine.setInt(this._uniforms[e], t) && (this._valueCache[e] = t); + } + /** + * Sets a int2 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First int in int2. + * @param y Second int in int2. + */ + setInt2(e, t, i) { + this._cacheFloat2(e, t, i) && (this.engine.setInt2(this._uniforms[e], t, i) || (this._valueCache[e] = null)); + } + /** + * Sets a int3 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First int in int3. + * @param y Second int in int3. + * @param z Third int in int3. + */ + setInt3(e, t, i, s) { + this._cacheFloat3(e, t, i, s) && (this.engine.setInt3(this._uniforms[e], t, i, s) || (this._valueCache[e] = null)); + } + /** + * Sets a int4 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First int in int4. + * @param y Second int in int4. + * @param z Third int in int4. + * @param w Fourth int in int4. + */ + setInt4(e, t, i, s, r) { + this._cacheFloat4(e, t, i, s, r) && (this.engine.setInt4(this._uniforms[e], t, i, s, r) || (this._valueCache[e] = null)); + } + /** + * Sets an int array on a uniform variable. + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setIntArray(e, t) { + this._valueCache[e] = null, this.engine.setIntArray(this._uniforms[e], t); + } + /** + * Sets an int array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setIntArray2(e, t) { + this._valueCache[e] = null, this.engine.setIntArray2(this._uniforms[e], t); + } + /** + * Sets an int array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setIntArray3(e, t) { + this._valueCache[e] = null, this.engine.setIntArray3(this._uniforms[e], t); + } + /** + * Sets an int array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setIntArray4(e, t) { + this._valueCache[e] = null, this.engine.setIntArray4(this._uniforms[e], t); + } + /** + * Sets an unsigned integer value on a uniform variable. + * @param uniformName Name of the variable. + * @param value Value to be set. + */ + setUInt(e, t) { + const i = this._valueCache[e]; + i !== void 0 && i === t || this.engine.setUInt(this._uniforms[e], t) && (this._valueCache[e] = t); + } + /** + * Sets an unsigned int2 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First unsigned int in uint2. + * @param y Second unsigned int in uint2. + */ + setUInt2(e, t, i) { + this._cacheFloat2(e, t, i) && (this.engine.setUInt2(this._uniforms[e], t, i) || (this._valueCache[e] = null)); + } + /** + * Sets an unsigned int3 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First unsigned int in uint3. + * @param y Second unsigned int in uint3. + * @param z Third unsigned int in uint3. + */ + setUInt3(e, t, i, s) { + this._cacheFloat3(e, t, i, s) && (this.engine.setUInt3(this._uniforms[e], t, i, s) || (this._valueCache[e] = null)); + } + /** + * Sets an unsigned int4 value on a uniform variable. + * @param uniformName Name of the variable. + * @param x First unsigned int in uint4. + * @param y Second unsigned int in uint4. + * @param z Third unsigned int in uint4. + * @param w Fourth unsigned int in uint4. + */ + setUInt4(e, t, i, s, r) { + this._cacheFloat4(e, t, i, s, r) && (this.engine.setUInt4(this._uniforms[e], t, i, s, r) || (this._valueCache[e] = null)); + } + /** + * Sets an unsigned int array on a uniform variable. + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setUIntArray(e, t) { + this._valueCache[e] = null, this.engine.setUIntArray(this._uniforms[e], t); + } + /** + * Sets an unsigned int array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setUIntArray2(e, t) { + this._valueCache[e] = null, this.engine.setUIntArray2(this._uniforms[e], t); + } + /** + * Sets an unsigned int array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setUIntArray3(e, t) { + this._valueCache[e] = null, this.engine.setUIntArray3(this._uniforms[e], t); + } + /** + * Sets an unsigned int array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setUIntArray4(e, t) { + this._valueCache[e] = null, this.engine.setUIntArray4(this._uniforms[e], t); + } + /** + * Sets an array on a uniform variable. + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setArray(e, t) { + this._valueCache[e] = null, this.engine.setArray(this._uniforms[e], t); + } + /** + * Sets an array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setArray2(e, t) { + this._valueCache[e] = null, this.engine.setArray2(this._uniforms[e], t); + } + /** + * Sets an array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + * @returns this effect. + */ + setArray3(e, t) { + this._valueCache[e] = null, this.engine.setArray3(this._uniforms[e], t); + } + /** + * Sets an array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader) + * @param uniformName Name of the variable. + * @param array array to be set. + */ + setArray4(e, t) { + this._valueCache[e] = null, this.engine.setArray4(this._uniforms[e], t); + } + /** + * Sets matrices on a uniform variable. + * @param uniformName Name of the variable. + * @param matrices matrices to be set. + */ + setMatrices(e, t) { + t && (this._valueCache[e] = null, this.engine.setMatrices(this._uniforms[e], t)); + } + /** + * Sets matrix on a uniform variable. + * @param uniformName Name of the variable. + * @param matrix matrix to be set. + */ + setMatrix(e, t) { + this._cacheMatrix(e, t) && (this.engine.setMatrices(this._uniforms[e], t.toArray()) || (this._valueCache[e] = null)); + } + /** + * Sets a 3x3 matrix on a uniform variable. (Specified as [1,2,3,4,5,6,7,8,9] will result in [1,2,3][4,5,6][7,8,9] matrix) + * @param uniformName Name of the variable. + * @param matrix matrix to be set. + */ + setMatrix3x3(e, t) { + this._valueCache[e] = null, this.engine.setMatrix3x3(this._uniforms[e], t); + } + /** + * Sets a 2x2 matrix on a uniform variable. (Specified as [1,2,3,4] will result in [1,2][3,4] matrix) + * @param uniformName Name of the variable. + * @param matrix matrix to be set. + */ + setMatrix2x2(e, t) { + this._valueCache[e] = null, this.engine.setMatrix2x2(this._uniforms[e], t); + } + /** + * Sets a float on a uniform variable. + * @param uniformName Name of the variable. + * @param value value to be set. + * @returns this effect. + */ + setFloat(e, t) { + const i = this._valueCache[e]; + i !== void 0 && i === t || this.engine.setFloat(this._uniforms[e], t) && (this._valueCache[e] = t); + } + /** + * Sets a Vector2 on a uniform variable. + * @param uniformName Name of the variable. + * @param vector2 vector2 to be set. + */ + setVector2(e, t) { + this._cacheFloat2(e, t.x, t.y) && (this.engine.setFloat2(this._uniforms[e], t.x, t.y) || (this._valueCache[e] = null)); + } + /** + * Sets a float2 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First float in float2. + * @param y Second float in float2. + */ + setFloat2(e, t, i) { + this._cacheFloat2(e, t, i) && (this.engine.setFloat2(this._uniforms[e], t, i) || (this._valueCache[e] = null)); + } + /** + * Sets a Vector3 on a uniform variable. + * @param uniformName Name of the variable. + * @param vector3 Value to be set. + */ + setVector3(e, t) { + this._cacheFloat3(e, t.x, t.y, t.z) && (this.engine.setFloat3(this._uniforms[e], t.x, t.y, t.z) || (this._valueCache[e] = null)); + } + /** + * Sets a float3 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First float in float3. + * @param y Second float in float3. + * @param z Third float in float3. + */ + setFloat3(e, t, i, s) { + this._cacheFloat3(e, t, i, s) && (this.engine.setFloat3(this._uniforms[e], t, i, s) || (this._valueCache[e] = null)); + } + /** + * Sets a Vector4 on a uniform variable. + * @param uniformName Name of the variable. + * @param vector4 Value to be set. + */ + setVector4(e, t) { + this._cacheFloat4(e, t.x, t.y, t.z, t.w) && (this.engine.setFloat4(this._uniforms[e], t.x, t.y, t.z, t.w) || (this._valueCache[e] = null)); + } + /** + * Sets a Quaternion on a uniform variable. + * @param uniformName Name of the variable. + * @param quaternion Value to be set. + */ + setQuaternion(e, t) { + this._cacheFloat4(e, t.x, t.y, t.z, t.w) && (this.engine.setFloat4(this._uniforms[e], t.x, t.y, t.z, t.w) || (this._valueCache[e] = null)); + } + /** + * Sets a float4 on a uniform variable. + * @param uniformName Name of the variable. + * @param x First float in float4. + * @param y Second float in float4. + * @param z Third float in float4. + * @param w Fourth float in float4. + * @returns this effect. + */ + setFloat4(e, t, i, s, r) { + this._cacheFloat4(e, t, i, s, r) && (this.engine.setFloat4(this._uniforms[e], t, i, s, r) || (this._valueCache[e] = null)); + } + /** + * Sets a Color3 on a uniform variable. + * @param uniformName Name of the variable. + * @param color3 Value to be set. + */ + setColor3(e, t) { + this._cacheFloat3(e, t.r, t.g, t.b) && (this.engine.setFloat3(this._uniforms[e], t.r, t.g, t.b) || (this._valueCache[e] = null)); + } + /** + * Sets a Color4 on a uniform variable. + * @param uniformName Name of the variable. + * @param color3 Value to be set. + * @param alpha Alpha value to be set. + */ + setColor4(e, t, i) { + this._cacheFloat4(e, t.r, t.g, t.b, i) && (this.engine.setFloat4(this._uniforms[e], t.r, t.g, t.b, i) || (this._valueCache[e] = null)); + } + /** + * Sets a Color4 on a uniform variable + * @param uniformName defines the name of the variable + * @param color4 defines the value to be set + */ + setDirectColor4(e, t) { + this._cacheFloat4(e, t.r, t.g, t.b, t.a) && (this.engine.setFloat4(this._uniforms[e], t.r, t.g, t.b, t.a) || (this._valueCache[e] = null)); + } + _getVertexShaderCode() { + return this.vertexShader ? this.engine._getShaderSource(this.vertexShader) : null; + } + _getFragmentShaderCode() { + return this.fragmentShader ? this.engine._getShaderSource(this.fragmentShader) : null; + } +} +class be { + /** + * @internal + */ + static SetMatrixPrecision(e) { + if (be.MatrixTrackPrecisionChange = !1, e && !be.MatrixUse64Bits && be.MatrixTrackedMatrices) + for (let t = 0; t < be.MatrixTrackedMatrices.length; ++t) { + const i = be.MatrixTrackedMatrices[t], s = i._m; + i._m = new Array(16); + for (let r = 0; r < 16; ++r) + i._m[r] = s[r]; + } + be.MatrixUse64Bits = e, be.MatrixCurrentType = be.MatrixUse64Bits ? Array : Float32Array, be.MatrixTrackedMatrices = null; + } +} +be.MatrixUse64Bits = !1; +be.MatrixTrackPrecisionChange = !0; +be.MatrixCurrentType = Float32Array; +be.MatrixTrackedMatrices = []; +class rs { + get underlyingResource() { + return this._webGLTexture; + } + constructor(e = null, t) { + if (this._MSAARenderBuffers = null, this._context = t, !e && (e = t.createTexture(), !e)) + throw new Error("Unable to create webGL texture"); + this.set(e); + } + setUsage() { + } + set(e) { + this._webGLTexture = e; + } + reset() { + this._webGLTexture = null, this._MSAARenderBuffers = null; + } + addMSAARenderBuffer(e) { + this._MSAARenderBuffers || (this._MSAARenderBuffers = []), this._MSAARenderBuffers.push(e); + } + releaseMSAARenderBuffers() { + if (this._MSAARenderBuffers) { + for (const e of this._MSAARenderBuffers) + this._context.deleteRenderbuffer(e); + this._MSAARenderBuffers = null; + } + } + release() { + this.releaseMSAARenderBuffers(), this._webGLTexture && this._context.deleteTexture(this._webGLTexture), this.reset(); + } +} +class Pi { + static IsWrapper(e) { + return e.getPipelineContext === void 0; + } + static GetEffect(e) { + return e.getPipelineContext === void 0 ? e.effect : e; + } + constructor(e, t = !0) { + this.effect = null, this.defines = null, this.drawContext = e.createDrawContext(), t && (this.materialContext = e.createMaterialContext()); + } + setEffect(e, t, i = !0) { + var s; + this.effect = e, t !== void 0 && (this.defines = t), i && ((s = this.drawContext) === null || s === void 0 || s.reset()); + } + dispose() { + var e; + (e = this.drawContext) === null || e === void 0 || e.dispose(); + } +} +class Gs { + get isDirty() { + return this._isStencilTestDirty || this._isStencilMaskDirty || this._isStencilFuncDirty || this._isStencilOpDirty; + } + get func() { + return this._func; + } + set func(e) { + this._func !== e && (this._func = e, this._isStencilFuncDirty = !0); + } + get funcRef() { + return this._funcRef; + } + set funcRef(e) { + this._funcRef !== e && (this._funcRef = e, this._isStencilFuncDirty = !0); + } + get funcMask() { + return this._funcMask; + } + set funcMask(e) { + this._funcMask !== e && (this._funcMask = e, this._isStencilFuncDirty = !0); + } + get opStencilFail() { + return this._opStencilFail; + } + set opStencilFail(e) { + this._opStencilFail !== e && (this._opStencilFail = e, this._isStencilOpDirty = !0); + } + get opDepthFail() { + return this._opDepthFail; + } + set opDepthFail(e) { + this._opDepthFail !== e && (this._opDepthFail = e, this._isStencilOpDirty = !0); + } + get opStencilDepthPass() { + return this._opStencilDepthPass; + } + set opStencilDepthPass(e) { + this._opStencilDepthPass !== e && (this._opStencilDepthPass = e, this._isStencilOpDirty = !0); + } + get mask() { + return this._mask; + } + set mask(e) { + this._mask !== e && (this._mask = e, this._isStencilMaskDirty = !0); + } + get enabled() { + return this._enabled; + } + set enabled(e) { + this._enabled !== e && (this._enabled = e, this._isStencilTestDirty = !0); + } + constructor(e = !0) { + this._isStencilTestDirty = !1, this._isStencilMaskDirty = !1, this._isStencilFuncDirty = !1, this._isStencilOpDirty = !1, this.useStencilGlobalOnly = !1, e && this.reset(); + } + reset() { + var e; + this.stencilMaterial = void 0, (e = this.stencilGlobal) === null || e === void 0 || e.reset(), this._isStencilTestDirty = !0, this._isStencilMaskDirty = !0, this._isStencilFuncDirty = !0, this._isStencilOpDirty = !0; + } + apply(e) { + var t; + if (!e) + return; + const i = !this.useStencilGlobalOnly && !!(!((t = this.stencilMaterial) === null || t === void 0) && t.enabled); + this.enabled = i ? this.stencilMaterial.enabled : this.stencilGlobal.enabled, this.func = i ? this.stencilMaterial.func : this.stencilGlobal.func, this.funcRef = i ? this.stencilMaterial.funcRef : this.stencilGlobal.funcRef, this.funcMask = i ? this.stencilMaterial.funcMask : this.stencilGlobal.funcMask, this.opStencilFail = i ? this.stencilMaterial.opStencilFail : this.stencilGlobal.opStencilFail, this.opDepthFail = i ? this.stencilMaterial.opDepthFail : this.stencilGlobal.opDepthFail, this.opStencilDepthPass = i ? this.stencilMaterial.opStencilDepthPass : this.stencilGlobal.opStencilDepthPass, this.mask = i ? this.stencilMaterial.mask : this.stencilGlobal.mask, this.isDirty && (this._isStencilTestDirty && (this.enabled ? e.enable(e.STENCIL_TEST) : e.disable(e.STENCIL_TEST), this._isStencilTestDirty = !1), this._isStencilMaskDirty && (e.stencilMask(this.mask), this._isStencilMaskDirty = !1), this._isStencilFuncDirty && (e.stencilFunc(this.func, this.funcRef, this.funcMask), this._isStencilFuncDirty = !1), this._isStencilOpDirty && (e.stencilOp(this.opStencilFail, this.opDepthFail, this.opStencilDepthPass), this._isStencilOpDirty = !1)); + } +} +class zs { +} +class se { + /** + * Returns the current npm package of the sdk + */ + // Not mixed with Version for tooling purpose. + static get NpmPackage() { + return "babylonjs@5.57.1"; + } + /** + * Returns the current version of the framework + */ + static get Version() { + return "5.57.1"; + } + /** + * Returns a string describing the current engine + */ + get description() { + let e = this.name + this.webGLVersion; + return this._caps.parallelShaderCompile && (e += " - Parallel shader compilation"), e; + } + /** + * Gets or sets the name of the engine + */ + get name() { + return this._name; + } + set name(e) { + this._name = e; + } + /** + * Returns the version of the engine + */ + get version() { + return this._webGLVersion; + } + get isDisposed() { + return this._isDisposed; + } + /** + * Gets or sets the relative url used to load shaders if using the engine in non-minified mode + */ + static get ShadersRepository() { + return Be.ShadersRepository; + } + static set ShadersRepository(e) { + Be.ShadersRepository = e; + } + /** + * @internal + */ + _getShaderProcessor(e) { + return this._shaderProcessor; + } + /** + * Gets or sets a boolean indicating if depth buffer should be reverse, going from far to near. + * This can provide greater z depth for distant objects. + */ + get useReverseDepthBuffer() { + return this._useReverseDepthBuffer; + } + set useReverseDepthBuffer(e) { + e !== this._useReverseDepthBuffer && (this._useReverseDepthBuffer = e, e ? this._depthCullingState.depthFunc = 518 : this._depthCullingState.depthFunc = 515); + } + /** + * Gets the current frame id + */ + get frameId() { + return this._frameId; + } + /** + * Gets a boolean indicating that the engine supports uniform buffers + * @see https://doc.babylonjs.com/setup/support/webGL2#uniform-buffer-objets + */ + get supportsUniformBuffers() { + return this.webGLVersion > 1 && !this.disableUniformBuffers; + } + /** + * Gets the options used for engine creation + * @returns EngineOptions object + */ + getCreationOptions() { + return this._creationOptions; + } + /** @internal */ + get _shouldUseHighPrecisionShader() { + return !!(this._caps.highPrecisionShaderSupported && this._highPrecisionShadersAllowed); + } + /** + * Gets a boolean indicating that only power of 2 textures are supported + * Please note that you can still use non power of 2 textures but in this case the engine will forcefully convert them + */ + get needPOTTextures() { + return this._webGLVersion < 2 || this.forcePOTTextures; + } + /** + * Gets the list of current active render loop functions + * @returns an array with the current render loop functions + */ + get activeRenderLoops() { + return this._activeRenderLoops; + } + /** + * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events + * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#handling-webgl-context-lost + */ + get doNotHandleContextLost() { + return this._doNotHandleContextLost; + } + set doNotHandleContextLost(e) { + this._doNotHandleContextLost = e; + } + get _supportsHardwareTextureRescaling() { + return !1; + } + /** + * sets the object from which width and height will be taken from when getting render width and height + * Will fallback to the gl object + * @param dimensions the framebuffer width and height that will be used. + */ + set framebufferDimensionsObject(e) { + this._framebufferDimensionsObject = e; + } + /** + * Gets the current viewport + */ + get currentViewport() { + return this._cachedViewport; + } + /** + * Gets the default empty texture + */ + get emptyTexture() { + return this._emptyTexture || (this._emptyTexture = this.createRawTexture(new Uint8Array(4), 1, 1, 5, !1, !1, 1)), this._emptyTexture; + } + /** + * Gets the default empty 3D texture + */ + get emptyTexture3D() { + return this._emptyTexture3D || (this._emptyTexture3D = this.createRawTexture3D(new Uint8Array(4), 1, 1, 1, 5, !1, !1, 1)), this._emptyTexture3D; + } + /** + * Gets the default empty 2D array texture + */ + get emptyTexture2DArray() { + return this._emptyTexture2DArray || (this._emptyTexture2DArray = this.createRawTexture2DArray(new Uint8Array(4), 1, 1, 1, 5, !1, !1, 1)), this._emptyTexture2DArray; + } + /** + * Gets the default empty cube texture + */ + get emptyCubeTexture() { + if (!this._emptyCubeTexture) { + const e = new Uint8Array(4), t = [e, e, e, e, e, e]; + this._emptyCubeTexture = this.createRawCubeTexture(t, 1, 5, 0, !1, !1, 1); + } + return this._emptyCubeTexture; + } + /** + * Gets a boolean indicating if the engine runs in WebGPU or not. + */ + get isWebGPU() { + return this._isWebGPU; + } + /** + * Gets the shader platform name used by the effects. + */ + get shaderPlatformName() { + return this._shaderPlatformName; + } + /** + * Enables or disables the snapshot rendering mode + * Note that the WebGL engine does not support snapshot rendering so setting the value won't have any effect for this engine + */ + get snapshotRendering() { + return !1; + } + set snapshotRendering(e) { + } + /** + * Gets or sets the snapshot rendering mode + */ + get snapshotRenderingMode() { + return this._snapshotRenderingMode; + } + set snapshotRenderingMode(e) { + this._snapshotRenderingMode = e; + } + /** + * Creates a new snapshot at the next frame using the current snapshotRenderingMode + */ + snapshotRenderingReset() { + this.snapshotRendering = !1; + } + static _CreateCanvas(e, t) { + if (typeof document > "u") + return new OffscreenCanvas(e, t); + const i = document.createElement("canvas"); + return i.width = e, i.height = t, i; + } + /** + * Create a canvas. This method is overridden by other engines + * @param width width + * @param height height + * @returns ICanvas interface + */ + createCanvas(e, t) { + return se._CreateCanvas(e, t); + } + /** + * Create an image to use with canvas + * @returns IImage interface + */ + createCanvasImage() { + return document.createElement("img"); + } + /** + * Creates a new engine + * @param canvasOrContext defines the canvas or WebGL context to use for rendering. If you provide a WebGL context, Babylon.js will not hook events on the canvas (like pointers, keyboards, etc...) so no event observables will be available. This is mostly used when Babylon.js is used as a plugin on a system which already used the WebGL context + * @param antialias defines enable antialiasing (default: false) + * @param options defines further options to be sent to the getContext() function + * @param adaptToDeviceRatio defines whether to adapt to the device's viewport characteristics (default: false) + */ + constructor(e, t, i, s) { + var r, n, a, o, h, c, u, d, g, f, m; + this._name = "WebGL", this._isDisposed = !1, this.forcePOTTextures = !1, this.isFullscreen = !1, this.cullBackFaces = null, this.renderEvenInBackground = !0, this.preventCacheWipeBetweenFrames = !1, this.validateShaderPrograms = !1, this._useReverseDepthBuffer = !1, this.isNDCHalfZRange = !1, this.hasOriginBottomLeft = !0, this.disableUniformBuffers = !1, this.onDisposeObservable = new w(), this._frameId = 0, this._uniformBuffers = new Array(), this._storageBuffers = new Array(), this._webGLVersion = 1, this._windowIsBackground = !1, this._highPrecisionShadersAllowed = !0, this._badOS = !1, this._badDesktopOS = !1, this._renderingQueueLaunched = !1, this._activeRenderLoops = new Array(), this.onContextLostObservable = new w(), this.onContextRestoredObservable = new w(), this._contextWasLost = !1, this._doNotHandleContextLost = !1, this.disableVertexArrayObjects = !1, this._colorWrite = !0, this._colorWriteChanged = !0, this._depthCullingState = new Ls(), this._stencilStateComposer = new Gs(), this._stencilState = new lt(), this._alphaState = new Us(), this._alphaMode = 1, this._alphaEquation = 0, this._internalTexturesCache = new Array(), this._renderTargetWrapperCache = new Array(), this._activeChannel = 0, this._currentTextureChannel = -1, this._boundTexturesCache = {}, this._compiledEffects = {}, this._vertexAttribArraysEnabled = [], this._uintIndicesCurrentlySet = !1, this._currentBoundBuffer = new Array(), this._currentFramebuffer = null, this._dummyFramebuffer = null, this._currentBufferPointers = new Array(), this._currentInstanceLocations = new Array(), this._currentInstanceBuffers = new Array(), this._vaoRecordInProgress = !1, this._mustWipeVertexAttributes = !1, this._nextFreeTextureSlots = new Array(), this._maxSimultaneousTextures = 0, this._maxMSAASamplesOverride = null, this._activeRequests = new Array(), this.adaptToDeviceRatio = !1, this._lastDevicePixelRatio = 1, this._transformTextureUrl = null, this.hostInformation = { + isMobile: !1 + }, this.premultipliedAlpha = !0, this.onBeforeTextureInitObservable = new w(), this._isWebGPU = !1, this._snapshotRenderingMode = 0, this._viewportCached = { x: 0, y: 0, z: 0, w: 0 }, this._unpackFlipYCached = null, this.enableUnpackFlipYCached = !0, this._boundUniforms = {}, this.startTime = Et.Now; + let b = null; + i = i || {}, this._creationOptions = i, this.adaptToDeviceRatio = s ?? !1, this._stencilStateComposer.stencilGlobal = this._stencilState, be.SetMatrixPrecision(!!i.useHighPrecisionMatrix), i.antialias = t ?? i.antialias, i.deterministicLockstep = (r = i.deterministicLockstep) !== null && r !== void 0 ? r : !1, i.lockstepMaxSteps = (n = i.lockstepMaxSteps) !== null && n !== void 0 ? n : 4, i.timeStep = (a = i.timeStep) !== null && a !== void 0 ? a : 1 / 60, i.audioEngine = (o = i.audioEngine) !== null && o !== void 0 ? o : !0, i.stencil = (h = i.stencil) !== null && h !== void 0 ? h : !0, this._audioContext = (u = (c = i.audioEngineOptions) === null || c === void 0 ? void 0 : c.audioContext) !== null && u !== void 0 ? u : null, this._audioDestination = (g = (d = i.audioEngineOptions) === null || d === void 0 ? void 0 : d.audioDestination) !== null && g !== void 0 ? g : null, this.premultipliedAlpha = (f = i.premultipliedAlpha) !== null && f !== void 0 ? f : !0, this.useExactSrgbConversions = (m = i.useExactSrgbConversions) !== null && m !== void 0 ? m : !1, this._doNotHandleContextLost = !!i.doNotHandleContextLost, this._isStencilEnable = !!i.stencil, s = s || i.adaptToDeviceRatio || !1; + const T = Ie() && window.devicePixelRatio || 1, M = i.limitDeviceRatio || T; + if (this._hardwareScalingLevel = s ? 1 / Math.min(M, T) : 1, this._lastDevicePixelRatio = T, !e) + return; + if (e.getContext) { + if (b = e, this._renderingCanvas = b, i.preserveDrawingBuffer === void 0 && (i.preserveDrawingBuffer = !1), i.xrCompatible === void 0 && (i.xrCompatible = !0), navigator && navigator.userAgent) { + this._setupMobileChecks(); + const A = navigator.userAgent; + for (const E of se.ExceptionList) { + const y = E.key, x = E.targets; + if (new RegExp(y).test(A)) { + if (E.capture && E.captureConstraint) { + const V = E.capture, W = E.captureConstraint, ee = new RegExp(V).exec(A); + if (ee && ee.length > 0 && parseInt(ee[ee.length - 1]) >= W) + continue; + } + for (const V of x) + switch (V) { + case "uniformBuffer": + this.disableUniformBuffers = !0; + break; + case "vao": + this.disableVertexArrayObjects = !0; + break; + case "antialias": + i.antialias = !1; + break; + case "maxMSAASamples": + this._maxMSAASamplesOverride = 1; + break; + } + } + } + } + if (this._doNotHandleContextLost || (this._onContextLost = (A) => { + A.preventDefault(), this._contextWasLost = !0, S.Warn("WebGL context lost."), this.onContextLostObservable.notifyObservers(this); + }, this._onContextRestored = () => { + this._restoreEngineAfterContextLost(this._initGLContext.bind(this)); + }, b.addEventListener("webglcontextlost", this._onContextLost, !1), b.addEventListener("webglcontextrestored", this._onContextRestored, !1), i.powerPreference = i.powerPreference || "high-performance"), this._badDesktopOS = /^((?!chrome|android).)*safari/i.test(navigator.userAgent), this._badDesktopOS && (i.xrCompatible = !1), !i.disableWebGL2Support) + try { + this._gl = b.getContext("webgl2", i) || b.getContext("experimental-webgl2", i), this._gl && (this._webGLVersion = 2, this._shaderPlatformName = "WEBGL2", this._gl.deleteQuery || (this._webGLVersion = 1, this._shaderPlatformName = "WEBGL1")); + } catch { + } + if (!this._gl) { + if (!b) + throw new Error("The provided canvas is null or undefined."); + try { + this._gl = b.getContext("webgl", i) || b.getContext("experimental-webgl", i); + } catch { + throw new Error("WebGL not supported"); + } + } + if (!this._gl) + throw new Error("WebGL not supported"); + } else { + this._gl = e, this._renderingCanvas = this._gl.canvas, this._gl.renderbufferStorageMultisample ? (this._webGLVersion = 2, this._shaderPlatformName = "WEBGL2") : this._shaderPlatformName = "WEBGL1"; + const A = this._gl.getContextAttributes(); + A && (i.stencil = A.stencil); + } + this._gl.pixelStorei(this._gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, this._gl.NONE), i.useHighPrecisionFloats !== void 0 && (this._highPrecisionShadersAllowed = i.useHighPrecisionFloats), this.resize(), this._initGLContext(), this._initFeatures(); + for (let A = 0; A < this._caps.maxVertexAttribs; A++) + this._currentBufferPointers[A] = new zs(); + this._shaderProcessor = this.webGLVersion > 1 ? new Vs() : new ks(), this._badOS = /iPad/i.test(navigator.userAgent) || /iPhone/i.test(navigator.userAgent); + const v = `Babylon.js v${se.Version}`; + console.log(v + ` - ${this.description}`), this._renderingCanvas && this._renderingCanvas.setAttribute && this._renderingCanvas.setAttribute("data-engine", v); + } + _setupMobileChecks() { + navigator && navigator.userAgent && (this._checkForMobile = () => { + const e = navigator.userAgent; + this.hostInformation.isMobile = e.indexOf("Mobile") !== -1 || // Needed for iOS 13+ detection on iPad (inspired by solution from https://stackoverflow.com/questions/9038625/detect-if-device-is-ios) + e.indexOf("Mac") !== -1 && Wt() && "ontouchend" in document; + }, this._checkForMobile(), Ie() && window.addEventListener("resize", this._checkForMobile)); + } + _restoreEngineAfterContextLost(e) { + setTimeout(async () => { + var t; + this._dummyFramebuffer = null; + const i = this._depthCullingState.depthTest, s = this._depthCullingState.depthFunc, r = this._depthCullingState.depthMask, n = this._stencilState.stencilTest; + await e(), this.wipeCaches(!0), this._rebuildEffects(), (t = this._rebuildComputeEffects) === null || t === void 0 || t.call(this), this._rebuildBuffers(), this._rebuildInternalTextures(), this._rebuildRenderTargetWrappers(), this.wipeCaches(!0), this._depthCullingState.depthTest = i, this._depthCullingState.depthFunc = s, this._depthCullingState.depthMask = r, this._stencilState.stencilTest = n, S.Warn(this.name + " context successfully restored."), this.onContextRestoredObservable.notifyObservers(this), this._contextWasLost = !1; + }, 0); + } + /** + * Shared initialization across engines types. + * @param canvas The canvas associated with this instance of the engine. + */ + _sharedInit(e) { + this._renderingCanvas = e; + } + /** + * @internal + */ + _getShaderProcessingContext(e) { + return null; + } + _rebuildInternalTextures() { + const e = this._internalTexturesCache.slice(); + for (const t of e) + t._rebuild(); + } + _rebuildRenderTargetWrappers() { + const e = this._renderTargetWrapperCache.slice(); + for (const t of e) + t._rebuild(); + } + _rebuildEffects() { + for (const e in this._compiledEffects) { + const t = this._compiledEffects[e]; + t._pipelineContext = null, t._wasPreviouslyReady = !1, t._prepareEffect(); + } + Be.ResetCache(); + } + /** + * Gets a boolean indicating if all created effects are ready + * @returns true if all effects are ready + */ + areAllEffectsReady() { + for (const e in this._compiledEffects) + if (!this._compiledEffects[e].isReady()) + return !1; + return !0; + } + _rebuildBuffers() { + for (const e of this._uniformBuffers) + e._rebuild(); + for (const e of this._storageBuffers) + e._rebuild(); + } + _initGLContext() { + var e; + this._caps = { + maxTexturesImageUnits: this._gl.getParameter(this._gl.MAX_TEXTURE_IMAGE_UNITS), + maxCombinedTexturesImageUnits: this._gl.getParameter(this._gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS), + maxVertexTextureImageUnits: this._gl.getParameter(this._gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS), + maxTextureSize: this._gl.getParameter(this._gl.MAX_TEXTURE_SIZE), + maxSamples: this._webGLVersion > 1 ? this._gl.getParameter(this._gl.MAX_SAMPLES) : 1, + maxCubemapTextureSize: this._gl.getParameter(this._gl.MAX_CUBE_MAP_TEXTURE_SIZE), + maxRenderTextureSize: this._gl.getParameter(this._gl.MAX_RENDERBUFFER_SIZE), + maxVertexAttribs: this._gl.getParameter(this._gl.MAX_VERTEX_ATTRIBS), + maxVaryingVectors: this._gl.getParameter(this._gl.MAX_VARYING_VECTORS), + maxFragmentUniformVectors: this._gl.getParameter(this._gl.MAX_FRAGMENT_UNIFORM_VECTORS), + maxVertexUniformVectors: this._gl.getParameter(this._gl.MAX_VERTEX_UNIFORM_VECTORS), + parallelShaderCompile: this._gl.getExtension("KHR_parallel_shader_compile") || void 0, + standardDerivatives: this._webGLVersion > 1 || this._gl.getExtension("OES_standard_derivatives") !== null, + maxAnisotropy: 1, + astc: this._gl.getExtension("WEBGL_compressed_texture_astc") || this._gl.getExtension("WEBKIT_WEBGL_compressed_texture_astc"), + bptc: this._gl.getExtension("EXT_texture_compression_bptc") || this._gl.getExtension("WEBKIT_EXT_texture_compression_bptc"), + s3tc: this._gl.getExtension("WEBGL_compressed_texture_s3tc") || this._gl.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc"), + // eslint-disable-next-line @typescript-eslint/naming-convention + s3tc_srgb: this._gl.getExtension("WEBGL_compressed_texture_s3tc_srgb") || this._gl.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc_srgb"), + pvrtc: this._gl.getExtension("WEBGL_compressed_texture_pvrtc") || this._gl.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc"), + etc1: this._gl.getExtension("WEBGL_compressed_texture_etc1") || this._gl.getExtension("WEBKIT_WEBGL_compressed_texture_etc1"), + etc2: this._gl.getExtension("WEBGL_compressed_texture_etc") || this._gl.getExtension("WEBKIT_WEBGL_compressed_texture_etc") || this._gl.getExtension("WEBGL_compressed_texture_es3_0"), + textureAnisotropicFilterExtension: this._gl.getExtension("EXT_texture_filter_anisotropic") || this._gl.getExtension("WEBKIT_EXT_texture_filter_anisotropic") || this._gl.getExtension("MOZ_EXT_texture_filter_anisotropic"), + uintIndices: this._webGLVersion > 1 || this._gl.getExtension("OES_element_index_uint") !== null, + fragmentDepthSupported: this._webGLVersion > 1 || this._gl.getExtension("EXT_frag_depth") !== null, + highPrecisionShaderSupported: !1, + timerQuery: this._gl.getExtension("EXT_disjoint_timer_query_webgl2") || this._gl.getExtension("EXT_disjoint_timer_query"), + supportOcclusionQuery: this._webGLVersion > 1, + canUseTimestampForTimerQuery: !1, + drawBuffersExtension: !1, + maxMSAASamples: 1, + colorBufferFloat: !!(this._webGLVersion > 1 && this._gl.getExtension("EXT_color_buffer_float")), + textureFloat: !!(this._webGLVersion > 1 || this._gl.getExtension("OES_texture_float")), + textureHalfFloat: !!(this._webGLVersion > 1 || this._gl.getExtension("OES_texture_half_float")), + textureHalfFloatRender: !1, + textureFloatLinearFiltering: !1, + textureFloatRender: !1, + textureHalfFloatLinearFiltering: !1, + vertexArrayObject: !1, + instancedArrays: !1, + textureLOD: !!(this._webGLVersion > 1 || this._gl.getExtension("EXT_shader_texture_lod")), + texelFetch: this._webGLVersion !== 1, + blendMinMax: !1, + multiview: this._gl.getExtension("OVR_multiview2"), + oculusMultiview: this._gl.getExtension("OCULUS_multiview"), + depthTextureExtension: !1, + canUseGLInstanceID: this._webGLVersion > 1, + canUseGLVertexID: this._webGLVersion > 1, + supportComputeShaders: !1, + supportSRGBBuffers: !1, + supportTransformFeedbacks: this._webGLVersion > 1, + textureMaxLevel: this._webGLVersion > 1, + texture2DArrayMaxLayerCount: this._webGLVersion > 1 ? this._gl.getParameter(this._gl.MAX_ARRAY_TEXTURE_LAYERS) : 128, + disableMorphTargetTexture: !1 + }, this._glVersion = this._gl.getParameter(this._gl.VERSION); + const t = this._gl.getExtension("WEBGL_debug_renderer_info"); + if (t != null && (this._glRenderer = this._gl.getParameter(t.UNMASKED_RENDERER_WEBGL), this._glVendor = this._gl.getParameter(t.UNMASKED_VENDOR_WEBGL)), this._glVendor || (this._glVendor = this._gl.getParameter(this._gl.VENDOR) || "Unknown vendor"), this._glRenderer || (this._glRenderer = this._gl.getParameter(this._gl.RENDERER) || "Unknown renderer"), this._gl.HALF_FLOAT_OES !== 36193 && (this._gl.HALF_FLOAT_OES = 36193), this._gl.RGBA16F !== 34842 && (this._gl.RGBA16F = 34842), this._gl.RGBA32F !== 34836 && (this._gl.RGBA32F = 34836), this._gl.DEPTH24_STENCIL8 !== 35056 && (this._gl.DEPTH24_STENCIL8 = 35056), this._caps.timerQuery && (this._webGLVersion === 1 && (this._gl.getQuery = this._caps.timerQuery.getQueryEXT.bind(this._caps.timerQuery)), this._caps.canUseTimestampForTimerQuery = ((e = this._gl.getQuery(this._caps.timerQuery.TIMESTAMP_EXT, this._caps.timerQuery.QUERY_COUNTER_BITS_EXT)) !== null && e !== void 0 ? e : 0) > 0), this._caps.maxAnisotropy = this._caps.textureAnisotropicFilterExtension ? this._gl.getParameter(this._caps.textureAnisotropicFilterExtension.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 0, this._caps.textureFloatLinearFiltering = !!(this._caps.textureFloat && this._gl.getExtension("OES_texture_float_linear")), this._caps.textureFloatRender = !!(this._caps.textureFloat && this._canRenderToFloatFramebuffer()), this._caps.textureHalfFloatLinearFiltering = !!(this._webGLVersion > 1 || this._caps.textureHalfFloat && this._gl.getExtension("OES_texture_half_float_linear")), this._caps.astc && (this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR), this._caps.bptc && (this._gl.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT = this._caps.bptc.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT), this._caps.s3tc_srgb && (this._gl.COMPRESSED_SRGB_S3TC_DXT1_EXT = this._caps.s3tc_srgb.COMPRESSED_SRGB_S3TC_DXT1_EXT, this._gl.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = this._caps.s3tc_srgb.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, this._gl.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = this._caps.s3tc_srgb.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT), this._caps.etc2 && (this._gl.COMPRESSED_SRGB8_ETC2 = this._caps.etc2.COMPRESSED_SRGB8_ETC2, this._gl.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = this._caps.etc2.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC), this._webGLVersion > 1 && this._gl.HALF_FLOAT_OES !== 5131 && (this._gl.HALF_FLOAT_OES = 5131), this._caps.textureHalfFloatRender = this._caps.textureHalfFloat && this._canRenderToHalfFloatFramebuffer(), this._webGLVersion > 1) + this._caps.drawBuffersExtension = !0, this._caps.maxMSAASamples = this._maxMSAASamplesOverride !== null ? this._maxMSAASamplesOverride : this._gl.getParameter(this._gl.MAX_SAMPLES); + else { + const i = this._gl.getExtension("WEBGL_draw_buffers"); + if (i !== null) { + this._caps.drawBuffersExtension = !0, this._gl.drawBuffers = i.drawBuffersWEBGL.bind(i), this._gl.DRAW_FRAMEBUFFER = this._gl.FRAMEBUFFER; + for (let s = 0; s < 16; s++) + this._gl["COLOR_ATTACHMENT" + s + "_WEBGL"] = i["COLOR_ATTACHMENT" + s + "_WEBGL"]; + } + } + if (this._webGLVersion > 1) + this._caps.depthTextureExtension = !0; + else { + const i = this._gl.getExtension("WEBGL_depth_texture"); + i != null && (this._caps.depthTextureExtension = !0, this._gl.UNSIGNED_INT_24_8 = i.UNSIGNED_INT_24_8_WEBGL); + } + if (this.disableVertexArrayObjects) + this._caps.vertexArrayObject = !1; + else if (this._webGLVersion > 1) + this._caps.vertexArrayObject = !0; + else { + const i = this._gl.getExtension("OES_vertex_array_object"); + i != null && (this._caps.vertexArrayObject = !0, this._gl.createVertexArray = i.createVertexArrayOES.bind(i), this._gl.bindVertexArray = i.bindVertexArrayOES.bind(i), this._gl.deleteVertexArray = i.deleteVertexArrayOES.bind(i)); + } + if (this._webGLVersion > 1) + this._caps.instancedArrays = !0; + else { + const i = this._gl.getExtension("ANGLE_instanced_arrays"); + i != null ? (this._caps.instancedArrays = !0, this._gl.drawArraysInstanced = i.drawArraysInstancedANGLE.bind(i), this._gl.drawElementsInstanced = i.drawElementsInstancedANGLE.bind(i), this._gl.vertexAttribDivisor = i.vertexAttribDivisorANGLE.bind(i)) : this._caps.instancedArrays = !1; + } + if (this._gl.getShaderPrecisionFormat) { + const i = this._gl.getShaderPrecisionFormat(this._gl.VERTEX_SHADER, this._gl.HIGH_FLOAT), s = this._gl.getShaderPrecisionFormat(this._gl.FRAGMENT_SHADER, this._gl.HIGH_FLOAT); + i && s && (this._caps.highPrecisionShaderSupported = i.precision !== 0 && s.precision !== 0); + } + if (this._webGLVersion > 1) + this._caps.blendMinMax = !0; + else { + const i = this._gl.getExtension("EXT_blend_minmax"); + i != null && (this._caps.blendMinMax = !0, this._gl.MAX = i.MAX_EXT, this._gl.MIN = i.MIN_EXT); + } + if (!this._caps.supportSRGBBuffers) { + if (this._webGLVersion > 1) + this._caps.supportSRGBBuffers = !0; + else { + const i = this._gl.getExtension("EXT_sRGB"); + i != null && (this._caps.supportSRGBBuffers = !0, this._gl.SRGB = i.SRGB_EXT, this._gl.SRGB8 = i.SRGB_ALPHA_EXT, this._gl.SRGB8_ALPHA8 = i.SRGB_ALPHA_EXT); + } + this._caps.supportSRGBBuffers = this._caps.supportSRGBBuffers && !!(this._creationOptions && this._creationOptions.forceSRGBBufferSupportState); + } + this._depthCullingState.depthTest = !0, this._depthCullingState.depthFunc = this._gl.LEQUAL, this._depthCullingState.depthMask = !0, this._maxSimultaneousTextures = this._caps.maxCombinedTexturesImageUnits; + for (let i = 0; i < this._maxSimultaneousTextures; i++) + this._nextFreeTextureSlots.push(i); + this._glRenderer === "Mali-G72" && (this._caps.disableMorphTargetTexture = !0); + } + _initFeatures() { + this._features = { + forceBitmapOverHTMLImageElement: !1, + supportRenderAndCopyToLodForFloatTextures: this._webGLVersion !== 1, + supportDepthStencilTexture: this._webGLVersion !== 1, + supportShadowSamplers: this._webGLVersion !== 1, + uniformBufferHardCheckMatrix: !1, + allowTexturePrefiltering: this._webGLVersion !== 1, + trackUbosInFrame: !1, + checkUbosContentBeforeUpload: !1, + supportCSM: this._webGLVersion !== 1, + basisNeedsPOT: this._webGLVersion === 1, + support3DTextures: this._webGLVersion !== 1, + needTypeSuffixInShaderConstants: this._webGLVersion !== 1, + supportMSAA: this._webGLVersion !== 1, + supportSSAO2: this._webGLVersion !== 1, + supportExtendedTextureFormats: this._webGLVersion !== 1, + supportSwitchCaseInShader: this._webGLVersion !== 1, + supportSyncTextureRead: !0, + needsInvertingBitmap: !0, + useUBOBindingCache: !0, + needShaderCodeInlining: !1, + needToAlwaysBindUniformBuffers: !1, + supportRenderPasses: !1, + supportSpriteInstancing: !0, + _collectUbosUpdatedInFrame: !1 + }; + } + /** + * Gets version of the current webGL context + * Keep it for back compat - use version instead + */ + get webGLVersion() { + return this._webGLVersion; + } + /** + * Gets a string identifying the name of the class + * @returns "Engine" string + */ + getClassName() { + return "ThinEngine"; + } + /** + * Returns true if the stencil buffer has been enabled through the creation option of the context. + */ + get isStencilEnable() { + return this._isStencilEnable; + } + /** @internal */ + _prepareWorkingCanvas() { + if (this._workingCanvas) + return; + this._workingCanvas = this.createCanvas(1, 1); + const e = this._workingCanvas.getContext("2d"); + e && (this._workingContext = e); + } + /** + * Reset the texture cache to empty state + */ + resetTextureCache() { + for (const e in this._boundTexturesCache) + Object.prototype.hasOwnProperty.call(this._boundTexturesCache, e) && (this._boundTexturesCache[e] = null); + this._currentTextureChannel = -1; + } + /** + * Gets an object containing information about the current engine context + * @returns an object containing the vendor, the renderer and the version of the current engine context + */ + getInfo() { + return this.getGlInfo(); + } + /** + * Gets an object containing information about the current webGL context + * @returns an object containing the vendor, the renderer and the version of the current webGL context + */ + getGlInfo() { + return { + vendor: this._glVendor, + renderer: this._glRenderer, + version: this._glVersion + }; + } + /** + * Defines the hardware scaling level. + * By default the hardware scaling level is computed from the window device ratio. + * if level = 1 then the engine will render at the exact resolution of the canvas. If level = 0.5 then the engine will render at twice the size of the canvas. + * @param level defines the level to use + */ + setHardwareScalingLevel(e) { + this._hardwareScalingLevel = e, this.resize(); + } + /** + * Gets the current hardware scaling level. + * By default the hardware scaling level is computed from the window device ratio. + * if level = 1 then the engine will render at the exact resolution of the canvas. If level = 0.5 then the engine will render at twice the size of the canvas. + * @returns a number indicating the current hardware scaling level + */ + getHardwareScalingLevel() { + return this._hardwareScalingLevel; + } + /** + * Gets the list of loaded textures + * @returns an array containing all loaded textures + */ + getLoadedTexturesCache() { + return this._internalTexturesCache; + } + /** + * Gets the object containing all engine capabilities + * @returns the EngineCapabilities object + */ + getCaps() { + return this._caps; + } + /** + * stop executing a render loop function and remove it from the execution array + * @param renderFunction defines the function to be removed. If not provided all functions will be removed. + */ + stopRenderLoop(e) { + if (!e) { + this._activeRenderLoops.length = 0; + return; + } + const t = this._activeRenderLoops.indexOf(e); + t >= 0 && this._activeRenderLoops.splice(t, 1); + } + /** @internal */ + _renderLoop() { + if (!this._contextWasLost) { + let e = !0; + if ((this._isDisposed || !this.renderEvenInBackground && this._windowIsBackground) && (e = !1), e) { + this.beginFrame(); + for (let t = 0; t < this._activeRenderLoops.length; t++) { + const i = this._activeRenderLoops[t]; + i(); + } + this.endFrame(); + } + } + this._activeRenderLoops.length > 0 ? this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow()) : this._renderingQueueLaunched = !1; + } + /** + * Gets the HTML canvas attached with the current webGL context + * @returns a HTML canvas + */ + getRenderingCanvas() { + return this._renderingCanvas; + } + /** + * Gets the audio context specified in engine initialization options + * @returns an Audio Context + */ + getAudioContext() { + return this._audioContext; + } + /** + * Gets the audio destination specified in engine initialization options + * @returns an audio destination node + */ + getAudioDestination() { + return this._audioDestination; + } + /** + * Gets host window + * @returns the host window object + */ + getHostWindow() { + return Ie() ? this._renderingCanvas && this._renderingCanvas.ownerDocument && this._renderingCanvas.ownerDocument.defaultView ? this._renderingCanvas.ownerDocument.defaultView : window : null; + } + /** + * Gets the current render width + * @param useScreen defines if screen size must be used (or the current render target if any) + * @returns a number defining the current render width + */ + getRenderWidth(e = !1) { + return !e && this._currentRenderTarget ? this._currentRenderTarget.width : this._framebufferDimensionsObject ? this._framebufferDimensionsObject.framebufferWidth : this._gl.drawingBufferWidth; + } + /** + * Gets the current render height + * @param useScreen defines if screen size must be used (or the current render target if any) + * @returns a number defining the current render height + */ + getRenderHeight(e = !1) { + return !e && this._currentRenderTarget ? this._currentRenderTarget.height : this._framebufferDimensionsObject ? this._framebufferDimensionsObject.framebufferHeight : this._gl.drawingBufferHeight; + } + /** + * Can be used to override the current requestAnimationFrame requester. + * @internal + */ + _queueNewFrame(e, t) { + return se.QueueNewFrame(e, t); + } + /** + * Register and execute a render loop. The engine can have more than one render function + * @param renderFunction defines the function to continuously execute + */ + runRenderLoop(e) { + this._activeRenderLoops.indexOf(e) === -1 && (this._activeRenderLoops.push(e), this._renderingQueueLaunched || (this._renderingQueueLaunched = !0, this._boundRenderFunction = this._renderLoop.bind(this), this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow()))); + } + /** + * Clear the current render buffer or the current render target (if any is set up) + * @param color defines the color to use + * @param backBuffer defines if the back buffer must be cleared + * @param depth defines if the depth buffer must be cleared + * @param stencil defines if the stencil buffer must be cleared + */ + clear(e, t, i, s = !1) { + const r = this.stencilStateComposer.useStencilGlobalOnly; + this.stencilStateComposer.useStencilGlobalOnly = !0, this.applyStates(), this.stencilStateComposer.useStencilGlobalOnly = r; + let n = 0; + t && e && (this._gl.clearColor(e.r, e.g, e.b, e.a !== void 0 ? e.a : 1), n |= this._gl.COLOR_BUFFER_BIT), i && (this.useReverseDepthBuffer ? (this._depthCullingState.depthFunc = this._gl.GEQUAL, this._gl.clearDepth(0)) : this._gl.clearDepth(1), n |= this._gl.DEPTH_BUFFER_BIT), s && (this._gl.clearStencil(0), n |= this._gl.STENCIL_BUFFER_BIT), this._gl.clear(n); + } + /** + * @internal + */ + _viewport(e, t, i, s) { + (e !== this._viewportCached.x || t !== this._viewportCached.y || i !== this._viewportCached.z || s !== this._viewportCached.w) && (this._viewportCached.x = e, this._viewportCached.y = t, this._viewportCached.z = i, this._viewportCached.w = s, this._gl.viewport(e, t, i, s)); + } + /** + * Set the WebGL's viewport + * @param viewport defines the viewport element to be used + * @param requiredWidth defines the width required for rendering. If not provided the rendering canvas' width is used + * @param requiredHeight defines the height required for rendering. If not provided the rendering canvas' height is used + */ + setViewport(e, t, i) { + const s = t || this.getRenderWidth(), r = i || this.getRenderHeight(), n = e.x || 0, a = e.y || 0; + this._cachedViewport = e, this._viewport(n * s, a * r, s * e.width, r * e.height); + } + /** + * Begin a new frame + */ + beginFrame() { + } + /** + * Enf the current frame + */ + endFrame() { + this._badOS && this.flushFramebuffer(), this._frameId++; + } + /** + * Resize the view according to the canvas' size + * @param forceSetSize true to force setting the sizes of the underlying canvas + */ + resize(e = !1) { + let t, i; + if (this.adaptToDeviceRatio) { + const s = Ie() && window.devicePixelRatio || 1, r = this._lastDevicePixelRatio / s; + this._lastDevicePixelRatio = s, this._hardwareScalingLevel *= r; + } + Ie() ? (t = this._renderingCanvas ? this._renderingCanvas.clientWidth || this._renderingCanvas.width : window.innerWidth, i = this._renderingCanvas ? this._renderingCanvas.clientHeight || this._renderingCanvas.height : window.innerHeight) : (t = this._renderingCanvas ? this._renderingCanvas.width : 100, i = this._renderingCanvas ? this._renderingCanvas.height : 100), this.setSize(t / this._hardwareScalingLevel, i / this._hardwareScalingLevel, e); + } + /** + * Force a specific size of the canvas + * @param width defines the new canvas' width + * @param height defines the new canvas' height + * @param forceSetSize true to force setting the sizes of the underlying canvas + * @returns true if the size was changed + */ + setSize(e, t, i = !1) { + return !this._renderingCanvas || (e = e | 0, t = t | 0, !i && this._renderingCanvas.width === e && this._renderingCanvas.height === t) ? !1 : (this._renderingCanvas.width = e, this._renderingCanvas.height = t, !0); + } + /** + * Binds the frame buffer to the specified texture. + * @param rtWrapper The render target wrapper to render to + * @param faceIndex The face of the texture to render to in case of cube texture and if the render target wrapper is not a multi render target + * @param requiredWidth The width of the target to render to + * @param requiredHeight The height of the target to render to + * @param forceFullscreenViewport Forces the viewport to be the entire texture/screen if true + * @param lodLevel Defines the lod level to bind to the frame buffer + * @param layer Defines the 2d array index to bind to the frame buffer if the render target wrapper is not a multi render target + */ + bindFramebuffer(e, t = 0, i, s, r, n = 0, a = 0) { + var o, h, c, u, d; + const g = e; + this._currentRenderTarget && this.unBindFramebuffer(this._currentRenderTarget), this._currentRenderTarget = e, this._bindUnboundFramebuffer(g._MSAAFramebuffer ? g._MSAAFramebuffer : g._framebuffer); + const f = this._gl; + e.isMulti || (e.is2DArray ? f.framebufferTextureLayer(f.FRAMEBUFFER, f.COLOR_ATTACHMENT0, (o = e.texture._hardwareTexture) === null || o === void 0 ? void 0 : o.underlyingResource, n, a) : e.isCube && f.framebufferTexture2D(f.FRAMEBUFFER, f.COLOR_ATTACHMENT0, f.TEXTURE_CUBE_MAP_POSITIVE_X + t, (h = e.texture._hardwareTexture) === null || h === void 0 ? void 0 : h.underlyingResource, n)); + const m = e._depthStencilTexture; + if (m) { + const b = e._depthStencilTextureWithStencil ? f.DEPTH_STENCIL_ATTACHMENT : f.DEPTH_ATTACHMENT; + e.is2DArray ? f.framebufferTextureLayer(f.FRAMEBUFFER, b, (c = m._hardwareTexture) === null || c === void 0 ? void 0 : c.underlyingResource, n, a) : e.isCube ? f.framebufferTexture2D(f.FRAMEBUFFER, b, f.TEXTURE_CUBE_MAP_POSITIVE_X + t, (u = m._hardwareTexture) === null || u === void 0 ? void 0 : u.underlyingResource, n) : f.framebufferTexture2D(f.FRAMEBUFFER, b, f.TEXTURE_2D, (d = m._hardwareTexture) === null || d === void 0 ? void 0 : d.underlyingResource, n); + } + this._cachedViewport && !r ? this.setViewport(this._cachedViewport, i, s) : (i || (i = e.width, n && (i = i / Math.pow(2, n))), s || (s = e.height, n && (s = s / Math.pow(2, n))), this._viewport(0, 0, i, s)), this.wipeCaches(); + } + /** + * Set various states to the webGL context + * @param culling defines culling state: true to enable culling, false to disable it + * @param zOffset defines the value to apply to zOffset (0 by default) + * @param force defines if states must be applied even if cache is up to date + * @param reverseSide defines if culling must be reversed (CCW if false, CW if true) + * @param cullBackFaces true to cull back faces, false to cull front faces (if culling is enabled) + * @param stencil stencil states to set + * @param zOffsetUnits defines the value to apply to zOffsetUnits (0 by default) + */ + setState(e, t = 0, i, s = !1, r, n, a = 0) { + var o, h; + (this._depthCullingState.cull !== e || i) && (this._depthCullingState.cull = e); + const c = !((h = (o = this.cullBackFaces) !== null && o !== void 0 ? o : r) !== null && h !== void 0) || h ? this._gl.BACK : this._gl.FRONT; + (this._depthCullingState.cullFace !== c || i) && (this._depthCullingState.cullFace = c), this.setZOffset(t), this.setZOffsetUnits(a); + const u = s ? this._gl.CW : this._gl.CCW; + (this._depthCullingState.frontFace !== u || i) && (this._depthCullingState.frontFace = u), this._stencilStateComposer.stencilMaterial = n; + } + /** + * Gets a boolean indicating if depth testing is enabled + * @returns the current state + */ + getDepthBuffer() { + return this._depthCullingState.depthTest; + } + /** + * Enable or disable depth buffering + * @param enable defines the state to set + */ + setDepthBuffer(e) { + this._depthCullingState.depthTest = e; + } + /** + * Set the z offset Factor to apply to current rendering + * @param value defines the offset to apply + */ + setZOffset(e) { + this._depthCullingState.zOffset = this.useReverseDepthBuffer ? -e : e; + } + /** + * Gets the current value of the zOffset Factor + * @returns the current zOffset Factor state + */ + getZOffset() { + const e = this._depthCullingState.zOffset; + return this.useReverseDepthBuffer ? -e : e; + } + /** + * Set the z offset Units to apply to current rendering + * @param value defines the offset to apply + */ + setZOffsetUnits(e) { + this._depthCullingState.zOffsetUnits = this.useReverseDepthBuffer ? -e : e; + } + /** + * Gets the current value of the zOffset Units + * @returns the current zOffset Units state + */ + getZOffsetUnits() { + const e = this._depthCullingState.zOffsetUnits; + return this.useReverseDepthBuffer ? -e : e; + } + /** + * @internal + */ + _bindUnboundFramebuffer(e) { + this._currentFramebuffer !== e && (this._gl.bindFramebuffer(this._gl.FRAMEBUFFER, e), this._currentFramebuffer = e); + } + /** @internal */ + _currentFrameBufferIsDefaultFrameBuffer() { + return this._currentFramebuffer === null; + } + /** + * Generates the mipmaps for a texture + * @param texture texture to generate the mipmaps for + */ + generateMipmaps(e) { + this._bindTextureDirectly(this._gl.TEXTURE_2D, e, !0), this._gl.generateMipmap(this._gl.TEXTURE_2D), this._bindTextureDirectly(this._gl.TEXTURE_2D, null); + } + /** + * Unbind the current render target texture from the webGL context + * @param texture defines the render target wrapper to unbind + * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated + * @param onBeforeUnbind defines a function which will be called before the effective unbind + */ + unBindFramebuffer(e, t = !1, i) { + var s; + const r = e; + this._currentRenderTarget = null; + const n = this._gl; + if (r._MSAAFramebuffer) { + if (e.isMulti) { + this.unBindMultiColorAttachmentFramebuffer(e, t, i); + return; + } + n.bindFramebuffer(n.READ_FRAMEBUFFER, r._MSAAFramebuffer), n.bindFramebuffer(n.DRAW_FRAMEBUFFER, r._framebuffer), n.blitFramebuffer(0, 0, e.width, e.height, 0, 0, e.width, e.height, n.COLOR_BUFFER_BIT, n.NEAREST); + } + !((s = e.texture) === null || s === void 0) && s.generateMipMaps && !t && !e.isCube && this.generateMipmaps(e.texture), i && (r._MSAAFramebuffer && this._bindUnboundFramebuffer(r._framebuffer), i()), this._bindUnboundFramebuffer(null); + } + /** + * Force a webGL flush (ie. a flush of all waiting webGL commands) + */ + flushFramebuffer() { + this._gl.flush(); + } + /** + * Unbind the current render target and bind the default framebuffer + */ + restoreDefaultFramebuffer() { + this._currentRenderTarget ? this.unBindFramebuffer(this._currentRenderTarget) : this._bindUnboundFramebuffer(null), this._cachedViewport && this.setViewport(this._cachedViewport), this.wipeCaches(); + } + // VBOs + /** @internal */ + _resetVertexBufferBinding() { + this.bindArrayBuffer(null), this._cachedVertexBuffers = null; + } + /** + * Creates a vertex buffer + * @param data the data for the vertex buffer + * @returns the new WebGL static buffer + */ + createVertexBuffer(e) { + return this._createVertexBuffer(e, this._gl.STATIC_DRAW); + } + _createVertexBuffer(e, t) { + const i = this._gl.createBuffer(); + if (!i) + throw new Error("Unable to create vertex buffer"); + const s = new Gt(i); + return this.bindArrayBuffer(s), e instanceof Array ? this._gl.bufferData(this._gl.ARRAY_BUFFER, new Float32Array(e), t) : this._gl.bufferData(this._gl.ARRAY_BUFFER, e, t), this._resetVertexBufferBinding(), s.references = 1, s; + } + /** + * Creates a dynamic vertex buffer + * @param data the data for the dynamic vertex buffer + * @returns the new WebGL dynamic buffer + */ + createDynamicVertexBuffer(e) { + return this._createVertexBuffer(e, this._gl.DYNAMIC_DRAW); + } + _resetIndexBufferBinding() { + this.bindIndexBuffer(null), this._cachedIndexBuffer = null; + } + /** + * Creates a new index buffer + * @param indices defines the content of the index buffer + * @param updatable defines if the index buffer must be updatable + * @returns a new webGL buffer + */ + createIndexBuffer(e, t) { + const i = this._gl.createBuffer(), s = new Gt(i); + if (!i) + throw new Error("Unable to create index buffer"); + this.bindIndexBuffer(s); + const r = this._normalizeIndexData(e); + return this._gl.bufferData(this._gl.ELEMENT_ARRAY_BUFFER, r, t ? this._gl.DYNAMIC_DRAW : this._gl.STATIC_DRAW), this._resetIndexBufferBinding(), s.references = 1, s.is32Bits = r.BYTES_PER_ELEMENT === 4, s; + } + _normalizeIndexData(e) { + if (e.BYTES_PER_ELEMENT === 2) + return e; + if (this._caps.uintIndices) { + if (e instanceof Uint32Array) + return e; + for (let i = 0; i < e.length; i++) + if (e[i] >= 65535) + return new Uint32Array(e); + return new Uint16Array(e); + } + return new Uint16Array(e); + } + /** + * Bind a webGL buffer to the webGL context + * @param buffer defines the buffer to bind + */ + bindArrayBuffer(e) { + this._vaoRecordInProgress || this._unbindVertexArrayObject(), this._bindBuffer(e, this._gl.ARRAY_BUFFER); + } + /** + * Bind a specific block at a given index in a specific shader program + * @param pipelineContext defines the pipeline context to use + * @param blockName defines the block name + * @param index defines the index where to bind the block + */ + bindUniformBlock(e, t, i) { + const s = e.program, r = this._gl.getUniformBlockIndex(s, t); + this._gl.uniformBlockBinding(s, r, i); + } + // eslint-disable-next-line @typescript-eslint/naming-convention + bindIndexBuffer(e) { + this._vaoRecordInProgress || this._unbindVertexArrayObject(), this._bindBuffer(e, this._gl.ELEMENT_ARRAY_BUFFER); + } + _bindBuffer(e, t) { + (this._vaoRecordInProgress || this._currentBoundBuffer[t] !== e) && (this._gl.bindBuffer(t, e ? e.underlyingResource : null), this._currentBoundBuffer[t] = e); + } + /** + * update the bound buffer with the given data + * @param data defines the data to update + */ + updateArrayBuffer(e) { + this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, e); + } + _vertexAttribPointer(e, t, i, s, r, n, a) { + const o = this._currentBufferPointers[t]; + if (!o) + return; + let h = !1; + o.active ? (o.buffer !== e && (o.buffer = e, h = !0), o.size !== i && (o.size = i, h = !0), o.type !== s && (o.type = s, h = !0), o.normalized !== r && (o.normalized = r, h = !0), o.stride !== n && (o.stride = n, h = !0), o.offset !== a && (o.offset = a, h = !0)) : (h = !0, o.active = !0, o.index = t, o.size = i, o.type = s, o.normalized = r, o.stride = n, o.offset = a, o.buffer = e), (h || this._vaoRecordInProgress) && (this.bindArrayBuffer(e), s === this._gl.UNSIGNED_INT || s === this._gl.INT ? this._gl.vertexAttribIPointer(t, i, s, n, a) : this._gl.vertexAttribPointer(t, i, s, r, n, a)); + } + /** + * @internal + */ + _bindIndexBufferWithCache(e) { + e != null && this._cachedIndexBuffer !== e && (this._cachedIndexBuffer = e, this.bindIndexBuffer(e), this._uintIndicesCurrentlySet = e.is32Bits); + } + _bindVertexBuffersAttributes(e, t, i) { + const s = t.getAttributesNames(); + this._vaoRecordInProgress || this._unbindVertexArrayObject(), this.unbindAllAttributes(); + for (let r = 0; r < s.length; r++) { + const n = t.getAttributeLocation(r); + if (n >= 0) { + const a = s[r]; + let o = null; + if (i && (o = i[a]), o || (o = e[a]), !o) + continue; + this._gl.enableVertexAttribArray(n), this._vaoRecordInProgress || (this._vertexAttribArraysEnabled[n] = !0); + const h = o.getBuffer(); + h && (this._vertexAttribPointer(h, n, o.getSize(), o.type, o.normalized, o.byteStride, o.byteOffset), o.getIsInstanced() && (this._gl.vertexAttribDivisor(n, o.getInstanceDivisor()), this._vaoRecordInProgress || (this._currentInstanceLocations.push(n), this._currentInstanceBuffers.push(h)))); + } + } + } + /** + * Records a vertex array object + * @see https://doc.babylonjs.com/setup/support/webGL2#vertex-array-objects + * @param vertexBuffers defines the list of vertex buffers to store + * @param indexBuffer defines the index buffer to store + * @param effect defines the effect to store + * @param overrideVertexBuffers defines optional list of avertex buffers that overrides the entries in vertexBuffers + * @returns the new vertex array object + */ + recordVertexArrayObject(e, t, i, s) { + const r = this._gl.createVertexArray(); + if (!r) + throw new Error("Unable to create VAO"); + return this._vaoRecordInProgress = !0, this._gl.bindVertexArray(r), this._mustWipeVertexAttributes = !0, this._bindVertexBuffersAttributes(e, i, s), this.bindIndexBuffer(t), this._vaoRecordInProgress = !1, this._gl.bindVertexArray(null), r; + } + /** + * Bind a specific vertex array object + * @see https://doc.babylonjs.com/setup/support/webGL2#vertex-array-objects + * @param vertexArrayObject defines the vertex array object to bind + * @param indexBuffer defines the index buffer to bind + */ + bindVertexArrayObject(e, t) { + this._cachedVertexArrayObject !== e && (this._cachedVertexArrayObject = e, this._gl.bindVertexArray(e), this._cachedVertexBuffers = null, this._cachedIndexBuffer = null, this._uintIndicesCurrentlySet = t != null && t.is32Bits, this._mustWipeVertexAttributes = !0); + } + /** + * Bind webGl buffers directly to the webGL context + * @param vertexBuffer defines the vertex buffer to bind + * @param indexBuffer defines the index buffer to bind + * @param vertexDeclaration defines the vertex declaration to use with the vertex buffer + * @param vertexStrideSize defines the vertex stride of the vertex buffer + * @param effect defines the effect associated with the vertex buffer + */ + bindBuffersDirectly(e, t, i, s, r) { + if (this._cachedVertexBuffers !== e || this._cachedEffectForVertexBuffers !== r) { + this._cachedVertexBuffers = e, this._cachedEffectForVertexBuffers = r; + const n = r.getAttributesCount(); + this._unbindVertexArrayObject(), this.unbindAllAttributes(); + let a = 0; + for (let o = 0; o < n; o++) + if (o < i.length) { + const h = r.getAttributeLocation(o); + h >= 0 && (this._gl.enableVertexAttribArray(h), this._vertexAttribArraysEnabled[h] = !0, this._vertexAttribPointer(e, h, i[o], this._gl.FLOAT, !1, s, a)), a += i[o] * 4; + } + } + this._bindIndexBufferWithCache(t); + } + _unbindVertexArrayObject() { + this._cachedVertexArrayObject && (this._cachedVertexArrayObject = null, this._gl.bindVertexArray(null)); + } + /** + * Bind a list of vertex buffers to the webGL context + * @param vertexBuffers defines the list of vertex buffers to bind + * @param indexBuffer defines the index buffer to bind + * @param effect defines the effect associated with the vertex buffers + * @param overrideVertexBuffers defines optional list of avertex buffers that overrides the entries in vertexBuffers + */ + bindBuffers(e, t, i, s) { + (this._cachedVertexBuffers !== e || this._cachedEffectForVertexBuffers !== i) && (this._cachedVertexBuffers = e, this._cachedEffectForVertexBuffers = i, this._bindVertexBuffersAttributes(e, i, s)), this._bindIndexBufferWithCache(t); + } + /** + * Unbind all instance attributes + */ + unbindInstanceAttributes() { + let e; + for (let t = 0, i = this._currentInstanceLocations.length; t < i; t++) { + const s = this._currentInstanceBuffers[t]; + e != s && s.references && (e = s, this.bindArrayBuffer(s)); + const r = this._currentInstanceLocations[t]; + this._gl.vertexAttribDivisor(r, 0); + } + this._currentInstanceBuffers.length = 0, this._currentInstanceLocations.length = 0; + } + /** + * Release and free the memory of a vertex array object + * @param vao defines the vertex array object to delete + */ + releaseVertexArrayObject(e) { + this._gl.deleteVertexArray(e); + } + /** + * @internal + */ + _releaseBuffer(e) { + return e.references--, e.references === 0 ? (this._deleteBuffer(e), !0) : !1; + } + _deleteBuffer(e) { + this._gl.deleteBuffer(e.underlyingResource); + } + /** + * Update the content of a webGL buffer used with instantiation and bind it to the webGL context + * @param instancesBuffer defines the webGL buffer to update and bind + * @param data defines the data to store in the buffer + * @param offsetLocations defines the offsets or attributes information used to determine where data must be stored in the buffer + */ + updateAndBindInstancesBuffer(e, t, i) { + if (this.bindArrayBuffer(e), t && this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, t), i[0].index !== void 0) + this.bindInstancesBuffer(e, i, !0); + else + for (let s = 0; s < 4; s++) { + const r = i[s]; + this._vertexAttribArraysEnabled[r] || (this._gl.enableVertexAttribArray(r), this._vertexAttribArraysEnabled[r] = !0), this._vertexAttribPointer(e, r, 4, this._gl.FLOAT, !1, 64, s * 16), this._gl.vertexAttribDivisor(r, 1), this._currentInstanceLocations.push(r), this._currentInstanceBuffers.push(e); + } + } + /** + * Bind the content of a webGL buffer used with instantiation + * @param instancesBuffer defines the webGL buffer to bind + * @param attributesInfo defines the offsets or attributes information used to determine where data must be stored in the buffer + * @param computeStride defines Whether to compute the strides from the info or use the default 0 + */ + bindInstancesBuffer(e, t, i = !0) { + this.bindArrayBuffer(e); + let s = 0; + if (i) + for (let r = 0; r < t.length; r++) { + const n = t[r]; + s += n.attributeSize * 4; + } + for (let r = 0; r < t.length; r++) { + const n = t[r]; + n.index === void 0 && (n.index = this._currentEffect.getAttributeLocationByName(n.attributeName)), !(n.index < 0) && (this._vertexAttribArraysEnabled[n.index] || (this._gl.enableVertexAttribArray(n.index), this._vertexAttribArraysEnabled[n.index] = !0), this._vertexAttribPointer(e, n.index, n.attributeSize, n.attributeType || this._gl.FLOAT, n.normalized || !1, s, n.offset), this._gl.vertexAttribDivisor(n.index, n.divisor === void 0 ? 1 : n.divisor), this._currentInstanceLocations.push(n.index), this._currentInstanceBuffers.push(e)); + } + } + /** + * Disable the instance attribute corresponding to the name in parameter + * @param name defines the name of the attribute to disable + */ + disableInstanceAttributeByName(e) { + if (!this._currentEffect) + return; + const t = this._currentEffect.getAttributeLocationByName(e); + this.disableInstanceAttribute(t); + } + /** + * Disable the instance attribute corresponding to the location in parameter + * @param attributeLocation defines the attribute location of the attribute to disable + */ + disableInstanceAttribute(e) { + let t = !1, i; + for (; (i = this._currentInstanceLocations.indexOf(e)) !== -1; ) + this._currentInstanceLocations.splice(i, 1), this._currentInstanceBuffers.splice(i, 1), t = !0, i = this._currentInstanceLocations.indexOf(e); + t && (this._gl.vertexAttribDivisor(e, 0), this.disableAttributeByIndex(e)); + } + /** + * Disable the attribute corresponding to the location in parameter + * @param attributeLocation defines the attribute location of the attribute to disable + */ + disableAttributeByIndex(e) { + this._gl.disableVertexAttribArray(e), this._vertexAttribArraysEnabled[e] = !1, this._currentBufferPointers[e].active = !1; + } + /** + * Send a draw order + * @param useTriangles defines if triangles must be used to draw (else wireframe will be used) + * @param indexStart defines the starting index + * @param indexCount defines the number of index to draw + * @param instancesCount defines the number of instances to draw (if instantiation is enabled) + */ + draw(e, t, i, s) { + this.drawElementsType(e ? 0 : 1, t, i, s); + } + /** + * Draw a list of points + * @param verticesStart defines the index of first vertex to draw + * @param verticesCount defines the count of vertices to draw + * @param instancesCount defines the number of instances to draw (if instantiation is enabled) + */ + drawPointClouds(e, t, i) { + this.drawArraysType(2, e, t, i); + } + /** + * Draw a list of unindexed primitives + * @param useTriangles defines if triangles must be used to draw (else wireframe will be used) + * @param verticesStart defines the index of first vertex to draw + * @param verticesCount defines the count of vertices to draw + * @param instancesCount defines the number of instances to draw (if instantiation is enabled) + */ + drawUnIndexed(e, t, i, s) { + this.drawArraysType(e ? 0 : 1, t, i, s); + } + /** + * Draw a list of indexed primitives + * @param fillMode defines the primitive to use + * @param indexStart defines the starting index + * @param indexCount defines the number of index to draw + * @param instancesCount defines the number of instances to draw (if instantiation is enabled) + */ + drawElementsType(e, t, i, s) { + this.applyStates(), this._reportDrawCall(); + const r = this._drawMode(e), n = this._uintIndicesCurrentlySet ? this._gl.UNSIGNED_INT : this._gl.UNSIGNED_SHORT, a = this._uintIndicesCurrentlySet ? 4 : 2; + s ? this._gl.drawElementsInstanced(r, i, n, t * a, s) : this._gl.drawElements(r, i, n, t * a); + } + /** + * Draw a list of unindexed primitives + * @param fillMode defines the primitive to use + * @param verticesStart defines the index of first vertex to draw + * @param verticesCount defines the count of vertices to draw + * @param instancesCount defines the number of instances to draw (if instantiation is enabled) + */ + drawArraysType(e, t, i, s) { + this.applyStates(), this._reportDrawCall(); + const r = this._drawMode(e); + s ? this._gl.drawArraysInstanced(r, t, i, s) : this._gl.drawArrays(r, t, i); + } + _drawMode(e) { + switch (e) { + case 0: + return this._gl.TRIANGLES; + case 2: + return this._gl.POINTS; + case 1: + return this._gl.LINES; + case 3: + return this._gl.POINTS; + case 4: + return this._gl.LINES; + case 5: + return this._gl.LINE_LOOP; + case 6: + return this._gl.LINE_STRIP; + case 7: + return this._gl.TRIANGLE_STRIP; + case 8: + return this._gl.TRIANGLE_FAN; + default: + return this._gl.TRIANGLES; + } + } + /** @internal */ + _reportDrawCall() { + } + // Shaders + /** + * @internal + */ + _releaseEffect(e) { + this._compiledEffects[e._key] && delete this._compiledEffects[e._key]; + const t = e.getPipelineContext(); + t && this._deletePipelineContext(t); + } + /** + * @internal + */ + _deletePipelineContext(e) { + const t = e; + t && t.program && (t.program.__SPECTOR_rebuildProgram = null, this._gl.deleteProgram(t.program)); + } + /** @internal */ + _getGlobalDefines(e) { + if (e) { + this.isNDCHalfZRange ? e.IS_NDC_HALF_ZRANGE = "" : delete e.IS_NDC_HALF_ZRANGE, this.useReverseDepthBuffer ? e.USE_REVERSE_DEPTHBUFFER = "" : delete e.USE_REVERSE_DEPTHBUFFER, this.useExactSrgbConversions ? e.USE_EXACT_SRGB_CONVERSIONS = "" : delete e.USE_EXACT_SRGB_CONVERSIONS; + return; + } else { + let t = ""; + return this.isNDCHalfZRange && (t += "#define IS_NDC_HALF_ZRANGE"), this.useReverseDepthBuffer && (t && (t += ` +`), t += "#define USE_REVERSE_DEPTHBUFFER"), this.useExactSrgbConversions && (t && (t += ` +`), t += "#define USE_EXACT_SRGB_CONVERSIONS"), t; + } + } + /** + * Create a new effect (used to store vertex/fragment shaders) + * @param baseName defines the base name of the effect (The name of file without .fragment.fx or .vertex.fx) + * @param attributesNamesOrOptions defines either a list of attribute names or an IEffectCreationOptions object + * @param uniformsNamesOrEngine defines either a list of uniform names or the engine to use + * @param samplers defines an array of string used to represent textures + * @param defines defines the string containing the defines to use to compile the shaders + * @param fallbacks defines the list of potential fallbacks to use if shader compilation fails + * @param onCompiled defines a function to call when the effect creation is successful + * @param onError defines a function to call when the effect creation has failed + * @param indexParameters defines an object containing the index values to use to compile shaders (like the maximum number of simultaneous lights) + * @param shaderLanguage the language the shader is written in (default: GLSL) + * @returns the new Effect + */ + createEffect(e, t, i, s, r, n, a, o, h, c = Ce.GLSL) { + var u; + const d = e.vertexElement || e.vertex || e.vertexToken || e.vertexSource || e, g = e.fragmentElement || e.fragment || e.fragmentToken || e.fragmentSource || e, f = this._getGlobalDefines(); + let m = (u = r ?? t.defines) !== null && u !== void 0 ? u : ""; + f && (m += f); + const b = d + "+" + g + "@" + m; + if (this._compiledEffects[b]) { + const M = this._compiledEffects[b]; + return a && M.isReady() && a(M), M; + } + const T = new Be(e, t, i, s, this, r, n, a, o, h, b, c); + return this._compiledEffects[b] = T, T; + } + // eslint-disable-next-line @typescript-eslint/naming-convention + static _ConcatenateShader(e, t, i = "") { + return i + (t ? t + ` +` : "") + e; + } + _compileShader(e, t, i, s) { + return this._compileRawShader(se._ConcatenateShader(e, i, s), t); + } + _compileRawShader(e, t) { + const i = this._gl, s = i.createShader(t === "vertex" ? i.VERTEX_SHADER : i.FRAGMENT_SHADER); + if (!s) { + let r = i.NO_ERROR, n = i.NO_ERROR; + for (; (n = i.getError()) !== i.NO_ERROR; ) + r = n; + throw new Error(`Something went wrong while creating a gl ${t} shader object. gl error=${r}, gl isContextLost=${i.isContextLost()}, _contextWasLost=${this._contextWasLost}`); + } + return i.shaderSource(s, e), i.compileShader(s), s; + } + /** + * @internal + */ + _getShaderSource(e) { + return this._gl.getShaderSource(e); + } + /** + * Directly creates a webGL program + * @param pipelineContext defines the pipeline context to attach to + * @param vertexCode defines the vertex shader code to use + * @param fragmentCode defines the fragment shader code to use + * @param context defines the webGL context to use (if not set, the current one will be used) + * @param transformFeedbackVaryings defines the list of transform feedback varyings to use + * @returns the new webGL program + */ + createRawShaderProgram(e, t, i, s, r = null) { + s = s || this._gl; + const n = this._compileRawShader(t, "vertex"), a = this._compileRawShader(i, "fragment"); + return this._createShaderProgram(e, n, a, s, r); + } + /** + * Creates a webGL program + * @param pipelineContext defines the pipeline context to attach to + * @param vertexCode defines the vertex shader code to use + * @param fragmentCode defines the fragment shader code to use + * @param defines defines the string containing the defines to use to compile the shaders + * @param context defines the webGL context to use (if not set, the current one will be used) + * @param transformFeedbackVaryings defines the list of transform feedback varyings to use + * @returns the new webGL program + */ + createShaderProgram(e, t, i, s, r, n = null) { + r = r || this._gl; + const a = this._webGLVersion > 1 ? `#version 300 es +#define WEBGL2 +` : "", o = this._compileShader(t, "vertex", s, a), h = this._compileShader(i, "fragment", s, a); + return this._createShaderProgram(e, o, h, r, n); + } + /** + * Inline functions in shader code that are marked to be inlined + * @param code code to inline + * @returns inlined code + */ + inlineShaderCode(e) { + return e; + } + /** + * Creates a new pipeline context + * @param shaderProcessingContext defines the shader processing context used during the processing if available + * @returns the new pipeline + */ + createPipelineContext(e) { + const t = new Ws(); + return t.engine = this, this._caps.parallelShaderCompile && (t.isParallelCompiled = !0), t; + } + /** + * Creates a new material context + * @returns the new context + */ + createMaterialContext() { + } + /** + * Creates a new draw context + * @returns the new context + */ + createDrawContext() { + } + _createShaderProgram(e, t, i, s, r = null) { + const n = s.createProgram(); + if (e.program = n, !n) + throw new Error("Unable to create program"); + return s.attachShader(n, t), s.attachShader(n, i), s.linkProgram(n), e.context = s, e.vertexShader = t, e.fragmentShader = i, e.isParallelCompiled || this._finalizePipelineContext(e), n; + } + _finalizePipelineContext(e) { + const t = e.context, i = e.vertexShader, s = e.fragmentShader, r = e.program; + if (!t.getProgramParameter(r, t.LINK_STATUS)) { + if (!this._gl.getShaderParameter(i, this._gl.COMPILE_STATUS)) { + const o = this._gl.getShaderInfoLog(i); + if (o) + throw e.vertexCompilationError = o, new Error("VERTEX SHADER " + o); + } + if (!this._gl.getShaderParameter(s, this._gl.COMPILE_STATUS)) { + const o = this._gl.getShaderInfoLog(s); + if (o) + throw e.fragmentCompilationError = o, new Error("FRAGMENT SHADER " + o); + } + const a = t.getProgramInfoLog(r); + if (a) + throw e.programLinkError = a, new Error(a); + } + if (this.validateShaderPrograms && (t.validateProgram(r), !t.getProgramParameter(r, t.VALIDATE_STATUS))) { + const o = t.getProgramInfoLog(r); + if (o) + throw e.programValidationError = o, new Error(o); + } + t.deleteShader(i), t.deleteShader(s), e.vertexShader = void 0, e.fragmentShader = void 0, e.onCompiled && (e.onCompiled(), e.onCompiled = void 0); + } + /** + * @internal + */ + _preparePipelineContext(e, t, i, s, r, n, a, o, h, c) { + const u = e; + s ? u.program = this.createRawShaderProgram(u, t, i, void 0, h) : u.program = this.createShaderProgram(u, t, i, o, void 0, h), u.program.__SPECTOR_rebuildProgram = a; + } + /** + * @internal + */ + _isRenderingStateCompiled(e) { + const t = e; + return this._gl.getProgramParameter(t.program, this._caps.parallelShaderCompile.COMPLETION_STATUS_KHR) ? (this._finalizePipelineContext(t), !0) : !1; + } + /** + * @internal + */ + _executeWhenRenderingStateIsCompiled(e, t) { + const i = e; + if (!i.isParallelCompiled) { + t(); + return; + } + const s = i.onCompiled; + s ? i.onCompiled = () => { + s(), t(); + } : i.onCompiled = t; + } + /** + * Gets the list of webGL uniform locations associated with a specific program based on a list of uniform names + * @param pipelineContext defines the pipeline context to use + * @param uniformsNames defines the list of uniform names + * @returns an array of webGL uniform locations + */ + getUniforms(e, t) { + const i = new Array(), s = e; + for (let r = 0; r < t.length; r++) + i.push(this._gl.getUniformLocation(s.program, t[r])); + return i; + } + /** + * Gets the list of active attributes for a given webGL program + * @param pipelineContext defines the pipeline context to use + * @param attributesNames defines the list of attribute names to get + * @returns an array of indices indicating the offset of each attribute + */ + getAttributes(e, t) { + const i = [], s = e; + for (let r = 0; r < t.length; r++) + try { + i.push(this._gl.getAttribLocation(s.program, t[r])); + } catch { + i.push(-1); + } + return i; + } + /** + * Activates an effect, making it the current one (ie. the one used for rendering) + * @param effect defines the effect to activate + */ + enableEffect(e) { + e = e !== null && Pi.IsWrapper(e) ? e.effect : e, !(!e || e === this._currentEffect) && (this._stencilStateComposer.stencilMaterial = void 0, e = e, this.bindSamplers(e), this._currentEffect = e, e.onBind && e.onBind(e), e._onBindObservable && e._onBindObservable.notifyObservers(e)); + } + /** + * Set the value of an uniform to a number (int) + * @param uniform defines the webGL uniform location where to store the value + * @param value defines the int number to store + * @returns true if the value was set + */ + setInt(e, t) { + return e ? (this._gl.uniform1i(e, t), !0) : !1; + } + /** + * Set the value of an uniform to a int2 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @returns true if the value was set + */ + setInt2(e, t, i) { + return e ? (this._gl.uniform2i(e, t, i), !0) : !1; + } + /** + * Set the value of an uniform to a int3 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @param z defines the 3rd component of the value + * @returns true if the value was set + */ + setInt3(e, t, i, s) { + return e ? (this._gl.uniform3i(e, t, i, s), !0) : !1; + } + /** + * Set the value of an uniform to a int4 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @param z defines the 3rd component of the value + * @param w defines the 4th component of the value + * @returns true if the value was set + */ + setInt4(e, t, i, s, r) { + return e ? (this._gl.uniform4i(e, t, i, s, r), !0) : !1; + } + /** + * Set the value of an uniform to an array of int32 + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of int32 to store + * @returns true if the value was set + */ + setIntArray(e, t) { + return e ? (this._gl.uniform1iv(e, t), !0) : !1; + } + /** + * Set the value of an uniform to an array of int32 (stored as vec2) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of int32 to store + * @returns true if the value was set + */ + setIntArray2(e, t) { + return !e || t.length % 2 !== 0 ? !1 : (this._gl.uniform2iv(e, t), !0); + } + /** + * Set the value of an uniform to an array of int32 (stored as vec3) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of int32 to store + * @returns true if the value was set + */ + setIntArray3(e, t) { + return !e || t.length % 3 !== 0 ? !1 : (this._gl.uniform3iv(e, t), !0); + } + /** + * Set the value of an uniform to an array of int32 (stored as vec4) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of int32 to store + * @returns true if the value was set + */ + setIntArray4(e, t) { + return !e || t.length % 4 !== 0 ? !1 : (this._gl.uniform4iv(e, t), !0); + } + /** + * Set the value of an uniform to a number (unsigned int) + * @param uniform defines the webGL uniform location where to store the value + * @param value defines the unsigned int number to store + * @returns true if the value was set + */ + setUInt(e, t) { + return e ? (this._gl.uniform1ui(e, t), !0) : !1; + } + /** + * Set the value of an uniform to a unsigned int2 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @returns true if the value was set + */ + setUInt2(e, t, i) { + return e ? (this._gl.uniform2ui(e, t, i), !0) : !1; + } + /** + * Set the value of an uniform to a unsigned int3 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @param z defines the 3rd component of the value + * @returns true if the value was set + */ + setUInt3(e, t, i, s) { + return e ? (this._gl.uniform3ui(e, t, i, s), !0) : !1; + } + /** + * Set the value of an uniform to a unsigned int4 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @param z defines the 3rd component of the value + * @param w defines the 4th component of the value + * @returns true if the value was set + */ + setUInt4(e, t, i, s, r) { + return e ? (this._gl.uniform4ui(e, t, i, s, r), !0) : !1; + } + /** + * Set the value of an uniform to an array of unsigned int32 + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of unsigned int32 to store + * @returns true if the value was set + */ + setUIntArray(e, t) { + return e ? (this._gl.uniform1uiv(e, t), !0) : !1; + } + /** + * Set the value of an uniform to an array of unsigned int32 (stored as vec2) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of unsigned int32 to store + * @returns true if the value was set + */ + setUIntArray2(e, t) { + return !e || t.length % 2 !== 0 ? !1 : (this._gl.uniform2uiv(e, t), !0); + } + /** + * Set the value of an uniform to an array of unsigned int32 (stored as vec3) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of unsigned int32 to store + * @returns true if the value was set + */ + setUIntArray3(e, t) { + return !e || t.length % 3 !== 0 ? !1 : (this._gl.uniform3uiv(e, t), !0); + } + /** + * Set the value of an uniform to an array of unsigned int32 (stored as vec4) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of unsigned int32 to store + * @returns true if the value was set + */ + setUIntArray4(e, t) { + return !e || t.length % 4 !== 0 ? !1 : (this._gl.uniform4uiv(e, t), !0); + } + /** + * Set the value of an uniform to an array of number + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of number to store + * @returns true if the value was set + */ + setArray(e, t) { + return !e || t.length < 1 ? !1 : (this._gl.uniform1fv(e, t), !0); + } + /** + * Set the value of an uniform to an array of number (stored as vec2) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of number to store + * @returns true if the value was set + */ + setArray2(e, t) { + return !e || t.length % 2 !== 0 ? !1 : (this._gl.uniform2fv(e, t), !0); + } + /** + * Set the value of an uniform to an array of number (stored as vec3) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of number to store + * @returns true if the value was set + */ + setArray3(e, t) { + return !e || t.length % 3 !== 0 ? !1 : (this._gl.uniform3fv(e, t), !0); + } + /** + * Set the value of an uniform to an array of number (stored as vec4) + * @param uniform defines the webGL uniform location where to store the value + * @param array defines the array of number to store + * @returns true if the value was set + */ + setArray4(e, t) { + return !e || t.length % 4 !== 0 ? !1 : (this._gl.uniform4fv(e, t), !0); + } + /** + * Set the value of an uniform to an array of float32 (stored as matrices) + * @param uniform defines the webGL uniform location where to store the value + * @param matrices defines the array of float32 to store + * @returns true if the value was set + */ + setMatrices(e, t) { + return e ? (this._gl.uniformMatrix4fv(e, !1, t), !0) : !1; + } + /** + * Set the value of an uniform to a matrix (3x3) + * @param uniform defines the webGL uniform location where to store the value + * @param matrix defines the Float32Array representing the 3x3 matrix to store + * @returns true if the value was set + */ + setMatrix3x3(e, t) { + return e ? (this._gl.uniformMatrix3fv(e, !1, t), !0) : !1; + } + /** + * Set the value of an uniform to a matrix (2x2) + * @param uniform defines the webGL uniform location where to store the value + * @param matrix defines the Float32Array representing the 2x2 matrix to store + * @returns true if the value was set + */ + setMatrix2x2(e, t) { + return e ? (this._gl.uniformMatrix2fv(e, !1, t), !0) : !1; + } + /** + * Set the value of an uniform to a number (float) + * @param uniform defines the webGL uniform location where to store the value + * @param value defines the float number to store + * @returns true if the value was transferred + */ + setFloat(e, t) { + return e ? (this._gl.uniform1f(e, t), !0) : !1; + } + /** + * Set the value of an uniform to a vec2 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @returns true if the value was set + */ + setFloat2(e, t, i) { + return e ? (this._gl.uniform2f(e, t, i), !0) : !1; + } + /** + * Set the value of an uniform to a vec3 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @param z defines the 3rd component of the value + * @returns true if the value was set + */ + setFloat3(e, t, i, s) { + return e ? (this._gl.uniform3f(e, t, i, s), !0) : !1; + } + /** + * Set the value of an uniform to a vec4 + * @param uniform defines the webGL uniform location where to store the value + * @param x defines the 1st component of the value + * @param y defines the 2nd component of the value + * @param z defines the 3rd component of the value + * @param w defines the 4th component of the value + * @returns true if the value was set + */ + setFloat4(e, t, i, s, r) { + return e ? (this._gl.uniform4f(e, t, i, s, r), !0) : !1; + } + // States + /** + * Apply all cached states (depth, culling, stencil and alpha) + */ + applyStates() { + if (this._depthCullingState.apply(this._gl), this._stencilStateComposer.apply(this._gl), this._alphaState.apply(this._gl), this._colorWriteChanged) { + this._colorWriteChanged = !1; + const e = this._colorWrite; + this._gl.colorMask(e, e, e, e); + } + } + /** + * Enable or disable color writing + * @param enable defines the state to set + */ + setColorWrite(e) { + e !== this._colorWrite && (this._colorWriteChanged = !0, this._colorWrite = e); + } + /** + * Gets a boolean indicating if color writing is enabled + * @returns the current color writing state + */ + getColorWrite() { + return this._colorWrite; + } + /** + * Gets the depth culling state manager + */ + get depthCullingState() { + return this._depthCullingState; + } + /** + * Gets the alpha state manager + */ + get alphaState() { + return this._alphaState; + } + /** + * Gets the stencil state manager + */ + get stencilState() { + return this._stencilState; + } + /** + * Gets the stencil state composer + */ + get stencilStateComposer() { + return this._stencilStateComposer; + } + // Textures + /** + * Clears the list of texture accessible through engine. + * This can help preventing texture load conflict due to name collision. + */ + clearInternalTexturesCache() { + this._internalTexturesCache.length = 0; + } + /** + * Force the entire cache to be cleared + * You should not have to use this function unless your engine needs to share the webGL context with another engine + * @param bruteForce defines a boolean to force clearing ALL caches (including stencil, detoh and alpha states) + */ + wipeCaches(e) { + this.preventCacheWipeBetweenFrames && !e || (this._currentEffect = null, this._viewportCached.x = 0, this._viewportCached.y = 0, this._viewportCached.z = 0, this._viewportCached.w = 0, this._unbindVertexArrayObject(), e && (this._currentProgram = null, this.resetTextureCache(), this._stencilStateComposer.reset(), this._depthCullingState.reset(), this._depthCullingState.depthFunc = this._gl.LEQUAL, this._alphaState.reset(), this._alphaMode = 1, this._alphaEquation = 0, this._colorWrite = !0, this._colorWriteChanged = !0, this._unpackFlipYCached = null, this._gl.pixelStorei(this._gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, this._gl.NONE), this._gl.pixelStorei(this._gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0), this._mustWipeVertexAttributes = !0, this.unbindAllAttributes()), this._resetVertexBufferBinding(), this._cachedIndexBuffer = null, this._cachedEffectForVertexBuffers = null, this.bindIndexBuffer(null)); + } + /** + * @internal + */ + _getSamplingParameters(e, t) { + const i = this._gl; + let s = i.NEAREST, r = i.NEAREST; + switch (e) { + case 11: + s = i.LINEAR, t ? r = i.LINEAR_MIPMAP_NEAREST : r = i.LINEAR; + break; + case 3: + s = i.LINEAR, t ? r = i.LINEAR_MIPMAP_LINEAR : r = i.LINEAR; + break; + case 8: + s = i.NEAREST, t ? r = i.NEAREST_MIPMAP_LINEAR : r = i.NEAREST; + break; + case 4: + s = i.NEAREST, t ? r = i.NEAREST_MIPMAP_NEAREST : r = i.NEAREST; + break; + case 5: + s = i.NEAREST, t ? r = i.LINEAR_MIPMAP_NEAREST : r = i.LINEAR; + break; + case 6: + s = i.NEAREST, t ? r = i.LINEAR_MIPMAP_LINEAR : r = i.LINEAR; + break; + case 7: + s = i.NEAREST, r = i.LINEAR; + break; + case 1: + s = i.NEAREST, r = i.NEAREST; + break; + case 9: + s = i.LINEAR, t ? r = i.NEAREST_MIPMAP_NEAREST : r = i.NEAREST; + break; + case 10: + s = i.LINEAR, t ? r = i.NEAREST_MIPMAP_LINEAR : r = i.NEAREST; + break; + case 2: + s = i.LINEAR, r = i.LINEAR; + break; + case 12: + s = i.LINEAR, r = i.NEAREST; + break; + } + return { + min: r, + mag: s + }; + } + /** @internal */ + _createTexture() { + const e = this._gl.createTexture(); + if (!e) + throw new Error("Unable to create texture"); + return e; + } + /** @internal */ + _createHardwareTexture() { + return new rs(this._createTexture(), this._gl); + } + /** + * Creates an internal texture without binding it to a framebuffer + * @internal + * @param size defines the size of the texture + * @param options defines the options used to create the texture + * @param delayGPUTextureCreation true to delay the texture creation the first time it is really needed. false to create it right away + * @param source source type of the texture + * @returns a new internal texture + */ + _createInternalTexture(e, t, i = !0, s = De.Unknown) { + var r; + let n = !1, a = 0, o = 3, h = 5, c = !1, u = 1, d; + t !== void 0 && typeof t == "object" ? (n = !!t.generateMipMaps, a = t.type === void 0 ? 0 : t.type, o = t.samplingMode === void 0 ? 3 : t.samplingMode, h = t.format === void 0 ? 5 : t.format, c = t.useSRGBBuffer === void 0 ? !1 : t.useSRGBBuffer, u = (r = t.samples) !== null && r !== void 0 ? r : 1, d = t.label) : n = !!t, c && (c = this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU)), (a === 1 && !this._caps.textureFloatLinearFiltering || a === 2 && !this._caps.textureHalfFloatLinearFiltering) && (o = 1), a === 1 && !this._caps.textureFloat && (a = 0, S.Warn("Float textures are not supported. Type forced to TEXTURETYPE_UNSIGNED_BYTE")); + const g = this._gl, f = new It(this, s), m = e.width || e, b = e.height || e, T = e.layers || 0, M = this._getSamplingParameters(o, n), v = T !== 0 ? g.TEXTURE_2D_ARRAY : g.TEXTURE_2D, A = this._getRGBABufferInternalSizedFormat(a, h, c), E = this._getInternalFormat(h), y = this._getWebGLTextureType(a); + return this._bindTextureDirectly(v, f), T !== 0 ? (f.is2DArray = !0, g.texImage3D(v, 0, A, m, b, T, 0, E, y, null)) : g.texImage2D(v, 0, A, m, b, 0, E, y, null), g.texParameteri(v, g.TEXTURE_MAG_FILTER, M.mag), g.texParameteri(v, g.TEXTURE_MIN_FILTER, M.min), g.texParameteri(v, g.TEXTURE_WRAP_S, g.CLAMP_TO_EDGE), g.texParameteri(v, g.TEXTURE_WRAP_T, g.CLAMP_TO_EDGE), n && this._gl.generateMipmap(v), this._bindTextureDirectly(v, null), f._useSRGBBuffer = c, f.baseWidth = m, f.baseHeight = b, f.width = m, f.height = b, f.depth = T, f.isReady = !0, f.samples = u, f.generateMipMaps = n, f.samplingMode = o, f.type = a, f.format = h, f.label = d, this._internalTexturesCache.push(f), f; + } + /** + * @internal + */ + _getUseSRGBBuffer(e, t) { + return e && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU || t); + } + _createTextureBase(e, t, i, s, r = 3, n = null, a = null, o, h, c = null, u = null, d = null, g = null, f, m, b) { + e = e || ""; + const T = e.substr(0, 5) === "data:", M = e.substr(0, 5) === "blob:", v = T && e.indexOf(";base64,") !== -1, A = u || new It(this, De.Url); + A !== u && (A.label = e.substring(0, 60)); + const E = e; + this._transformTextureUrl && !v && !u && !c && (e = this._transformTextureUrl(e)), E !== e && (A._originalUrl = E); + const y = e.lastIndexOf("."); + let x = g || (y > -1 ? e.substring(y).toLowerCase() : ""), D = null; + x.indexOf("?") > -1 && (x = x.split("?")[0]); + for (const ee of se._TextureLoaders) + if (ee.canLoad(x, f)) { + D = ee; + break; + } + s && s.addPendingData(A), A.url = e, A.generateMipMaps = !t, A.samplingMode = r, A.invertY = i, A._useSRGBBuffer = this._getUseSRGBBuffer(!!b, t), this._doNotHandleContextLost || (A._buffer = c); + let W = null; + n && !u && (W = A.onLoadedObservable.add(n)), u || this._internalTexturesCache.push(A); + const ce = (ee, oe) => { + s && s.removePendingData(A), e === E ? (W && A.onLoadedObservable.remove(W), J.UseFallbackTexture && this._createTextureBase(J.FallbackTexture, t, A.invertY, s, r, null, a, o, h, c, A), ee = (ee || "Unknown error") + (J.UseFallbackTexture ? " - Fallback texture was used" : ""), A.onErrorObservable.notifyObservers({ message: ee, exception: oe }), a && a(ee, oe)) : (S.Warn(`Failed to load ${e}, falling back to ${E}`), this._createTextureBase(E, t, A.invertY, s, r, n, a, o, h, c, A, d, g, f, m, b)); + }; + if (D) { + const ee = (oe) => { + D.loadData(oe, A, ($, Pe, Ae, Fe, Te, Me) => { + Me ? ce("TextureLoader failed to load data") : o(A, x, s, { width: $, height: Pe }, A.invertY, !Ae, Fe, () => (Te(), !1), r); + }, m); + }; + c ? c instanceof ArrayBuffer ? ee(new Uint8Array(c)) : ArrayBuffer.isView(c) ? ee(c) : a && a("Unable to load: only ArrayBuffer or ArrayBufferView is supported", null) : this._loadFile(e, (oe) => ee(new Uint8Array(oe)), void 0, s ? s.offlineProvider : void 0, !0, (oe, $) => { + ce("Unable to load " + (oe && oe.responseURL, $)); + }); + } else { + const ee = (oe) => { + M && !this._doNotHandleContextLost && (A._buffer = oe), o(A, x, s, oe, A.invertY, t, !1, h, r); + }; + !T || v ? c && (typeof c.decoding == "string" || c.close) ? ee(c) : se._FileToolsLoadImage(e, ee, ce, s ? s.offlineProvider : null, f, A.invertY && this._features.needsInvertingBitmap ? { imageOrientation: "flipY" } : void 0) : typeof c == "string" || c instanceof ArrayBuffer || ArrayBuffer.isView(c) || c instanceof Blob ? se._FileToolsLoadImage(c, ee, ce, s ? s.offlineProvider : null, f, A.invertY && this._features.needsInvertingBitmap ? { imageOrientation: "flipY" } : void 0) : c && ee(c); + } + return A; + } + /** + * Usually called from Texture.ts. + * Passed information to create a WebGLTexture + * @param url defines a value which contains one of the following: + * * A conventional http URL, e.g. 'http://...' or 'file://...' + * * A base64 string of in-line texture data, e.g. 'data:image/jpg;base64,/...' + * * An indicator that data being passed using the buffer parameter, e.g. 'data:mytexture.jpg' + * @param noMipmap defines a boolean indicating that no mipmaps shall be generated. Ignored for compressed textures. They must be in the file + * @param invertY when true, image is flipped when loaded. You probably want true. Certain compressed textures may invert this if their default is inverted (eg. ktx) + * @param scene needed for loading to the correct scene + * @param samplingMode mode with should be used sample / access the texture (Default: Texture.TRILINEAR_SAMPLINGMODE) + * @param onLoad optional callback to be called upon successful completion + * @param onError optional callback to be called upon failure + * @param buffer a source of a file previously fetched as either a base64 string, an ArrayBuffer (compressed or image format), HTMLImageElement (image format), or a Blob + * @param fallback an internal argument in case the function must be called again, due to etc1 not having alpha capabilities + * @param format internal format. Default: RGB when extension is '.jpg' else RGBA. Ignored for compressed textures + * @param forcedExtension defines the extension to use to pick the right loader + * @param mimeType defines an optional mime type + * @param loaderOptions options to be passed to the loader + * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg) + * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU). + * @returns a InternalTexture for assignment back into BABYLON.Texture + */ + createTexture(e, t, i, s, r = 3, n = null, a = null, o = null, h = null, c = null, u = null, d, g, f, m) { + return this._createTextureBase(e, t, i, s, r, n, a, this._prepareWebGLTexture.bind(this), (b, T, M, v, A, E) => { + const y = this._gl, x = M.width === b && M.height === T, D = c ? this._getInternalFormat(c, A._useSRGBBuffer) : v === ".jpg" && !A._useSRGBBuffer ? y.RGB : A._useSRGBBuffer ? y.SRGB8_ALPHA8 : y.RGBA; + let V = c ? this._getInternalFormat(c) : v === ".jpg" && !A._useSRGBBuffer ? y.RGB : y.RGBA; + if (A._useSRGBBuffer && this.webGLVersion === 1 && (V = D), x) + return y.texImage2D(y.TEXTURE_2D, 0, D, V, y.UNSIGNED_BYTE, M), !1; + const W = this._caps.maxTextureSize; + if (M.width > W || M.height > W || !this._supportsHardwareTextureRescaling) + return this._prepareWorkingCanvas(), !this._workingCanvas || !this._workingContext || (this._workingCanvas.width = b, this._workingCanvas.height = T, this._workingContext.drawImage(M, 0, 0, M.width, M.height, 0, 0, b, T), y.texImage2D(y.TEXTURE_2D, 0, D, V, y.UNSIGNED_BYTE, this._workingCanvas), A.width = b, A.height = T), !1; + { + const ce = new It(this, De.Temp); + this._bindTextureDirectly(y.TEXTURE_2D, ce, !0), y.texImage2D(y.TEXTURE_2D, 0, D, V, y.UNSIGNED_BYTE, M), this._rescaleTexture(ce, A, s, D, () => { + this._releaseTexture(ce), this._bindTextureDirectly(y.TEXTURE_2D, A, !0), E(); + }); + } + return !0; + }, o, h, c, u, d, g, m); + } + /** + * Loads an image as an HTMLImageElement. + * @param input url string, ArrayBuffer, or Blob to load + * @param onLoad callback called when the image successfully loads + * @param onError callback called when the image fails to load + * @param offlineProvider offline provider for caching + * @param mimeType optional mime type + * @param imageBitmapOptions optional the options to use when creating an ImageBitmap + * @returns the HTMLImageElement of the loaded image + * @internal + */ + static _FileToolsLoadImage(e, t, i, s, r, n) { + throw Y("FileTools"); + } + /** + * @internal + */ + _rescaleTexture(e, t, i, s, r) { + } + /** + * Creates a raw texture + * @param data defines the data to store in the texture + * @param width defines the width of the texture + * @param height defines the height of the texture + * @param format defines the format of the data + * @param generateMipMaps defines if the engine should generate the mip levels + * @param invertY defines if data must be stored with Y axis inverted + * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default) + * @param compression defines the compression used (null by default) + * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default) + * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg) + * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU). + * @returns the raw texture inside an InternalTexture + */ + createRawTexture(e, t, i, s, r, n, a, o = null, h = 0, c = 0, u = !1) { + throw Y("Engine.RawTexture"); + } + /** + * Creates a new raw cube texture + * @param data defines the array of data to use to create each face + * @param size defines the size of the textures + * @param format defines the format of the data + * @param type defines the type of the data (like Engine.TEXTURETYPE_UNSIGNED_INT) + * @param generateMipMaps defines if the engine should generate the mip levels + * @param invertY defines if data must be stored with Y axis inverted + * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE) + * @param compression defines the compression used (null by default) + * @returns the cube texture as an InternalTexture + */ + createRawCubeTexture(e, t, i, s, r, n, a, o = null) { + throw Y("Engine.RawTexture"); + } + /** + * Creates a new raw 3D texture + * @param data defines the data used to create the texture + * @param width defines the width of the texture + * @param height defines the height of the texture + * @param depth defines the depth of the texture + * @param format defines the format of the texture + * @param generateMipMaps defines if the engine must generate mip levels + * @param invertY defines if data must be stored with Y axis inverted + * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE) + * @param compression defines the compressed used (can be null) + * @param textureType defines the compressed used (can be null) + * @returns a new raw 3D texture (stored in an InternalTexture) + */ + createRawTexture3D(e, t, i, s, r, n, a, o, h = null, c = 0) { + throw Y("Engine.RawTexture"); + } + /** + * Creates a new raw 2D array texture + * @param data defines the data used to create the texture + * @param width defines the width of the texture + * @param height defines the height of the texture + * @param depth defines the number of layers of the texture + * @param format defines the format of the texture + * @param generateMipMaps defines if the engine must generate mip levels + * @param invertY defines if data must be stored with Y axis inverted + * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE) + * @param compression defines the compressed used (can be null) + * @param textureType defines the compressed used (can be null) + * @returns a new raw 2D array texture (stored in an InternalTexture) + */ + createRawTexture2DArray(e, t, i, s, r, n, a, o, h = null, c = 0) { + throw Y("Engine.RawTexture"); + } + /** + * @internal + */ + _unpackFlipY(e) { + this._unpackFlipYCached !== e && (this._gl.pixelStorei(this._gl.UNPACK_FLIP_Y_WEBGL, e ? 1 : 0), this.enableUnpackFlipYCached && (this._unpackFlipYCached = e)); + } + /** @internal */ + _getUnpackAlignement() { + return this._gl.getParameter(this._gl.UNPACK_ALIGNMENT); + } + _getTextureTarget(e) { + return e.isCube ? this._gl.TEXTURE_CUBE_MAP : e.is3D ? this._gl.TEXTURE_3D : e.is2DArray || e.isMultiview ? this._gl.TEXTURE_2D_ARRAY : this._gl.TEXTURE_2D; + } + /** + * Update the sampling mode of a given texture + * @param samplingMode defines the required sampling mode + * @param texture defines the texture to update + * @param generateMipMaps defines whether to generate mipmaps for the texture + */ + updateTextureSamplingMode(e, t, i = !1) { + const s = this._getTextureTarget(t), r = this._getSamplingParameters(e, t.useMipMaps || i); + this._setTextureParameterInteger(s, this._gl.TEXTURE_MAG_FILTER, r.mag, t), this._setTextureParameterInteger(s, this._gl.TEXTURE_MIN_FILTER, r.min), i && (t.generateMipMaps = !0, this._gl.generateMipmap(s)), this._bindTextureDirectly(s, null), t.samplingMode = e; + } + /** + * Update the dimensions of a texture + * @param texture texture to update + * @param width new width of the texture + * @param height new height of the texture + * @param depth new depth of the texture + */ + updateTextureDimensions(e, t, i, s = 1) { + } + /** + * Update the sampling mode of a given texture + * @param texture defines the texture to update + * @param wrapU defines the texture wrap mode of the u coordinates + * @param wrapV defines the texture wrap mode of the v coordinates + * @param wrapR defines the texture wrap mode of the r coordinates + */ + updateTextureWrappingMode(e, t, i = null, s = null) { + const r = this._getTextureTarget(e); + t !== null && (this._setTextureParameterInteger(r, this._gl.TEXTURE_WRAP_S, this._getTextureWrapMode(t), e), e._cachedWrapU = t), i !== null && (this._setTextureParameterInteger(r, this._gl.TEXTURE_WRAP_T, this._getTextureWrapMode(i), e), e._cachedWrapV = i), (e.is2DArray || e.is3D) && s !== null && (this._setTextureParameterInteger(r, this._gl.TEXTURE_WRAP_R, this._getTextureWrapMode(s), e), e._cachedWrapR = s), this._bindTextureDirectly(r, null); + } + /** + * @internal + */ + _setupDepthStencilTexture(e, t, i, s, r, n = 1) { + const a = t.width || t, o = t.height || t, h = t.layers || 0; + e.baseWidth = a, e.baseHeight = o, e.width = a, e.height = o, e.is2DArray = h > 0, e.depth = h, e.isReady = !0, e.samples = n, e.generateMipMaps = !1, e.samplingMode = s ? 2 : 1, e.type = 0, e._comparisonFunction = r; + const c = this._gl, u = this._getTextureTarget(e), d = this._getSamplingParameters(e.samplingMode, !1); + c.texParameteri(u, c.TEXTURE_MAG_FILTER, d.mag), c.texParameteri(u, c.TEXTURE_MIN_FILTER, d.min), c.texParameteri(u, c.TEXTURE_WRAP_S, c.CLAMP_TO_EDGE), c.texParameteri(u, c.TEXTURE_WRAP_T, c.CLAMP_TO_EDGE), this.webGLVersion > 1 && (r === 0 ? (c.texParameteri(u, c.TEXTURE_COMPARE_FUNC, 515), c.texParameteri(u, c.TEXTURE_COMPARE_MODE, c.NONE)) : (c.texParameteri(u, c.TEXTURE_COMPARE_FUNC, r), c.texParameteri(u, c.TEXTURE_COMPARE_MODE, c.COMPARE_REF_TO_TEXTURE))); + } + /** + * @internal + */ + _uploadCompressedDataToTextureDirectly(e, t, i, s, r, n = 0, a = 0) { + const o = this._gl; + let h = o.TEXTURE_2D; + if (e.isCube && (h = o.TEXTURE_CUBE_MAP_POSITIVE_X + n), e._useSRGBBuffer) + switch (t) { + case 37492: + case 36196: + this._caps.etc2 ? t = o.COMPRESSED_SRGB8_ETC2 : e._useSRGBBuffer = !1; + break; + case 37496: + this._caps.etc2 ? t = o.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : e._useSRGBBuffer = !1; + break; + case 36492: + t = o.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT; + break; + case 37808: + t = o.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR; + break; + case 33776: + this._caps.s3tc_srgb ? t = o.COMPRESSED_SRGB_S3TC_DXT1_EXT : e._useSRGBBuffer = !1; + break; + case 33777: + this._caps.s3tc_srgb ? t = o.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT : e._useSRGBBuffer = !1; + break; + case 33779: + this._caps.s3tc_srgb ? t = o.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : e._useSRGBBuffer = !1; + break; + default: + e._useSRGBBuffer = !1; + break; + } + this._gl.compressedTexImage2D(h, a, t, i, s, 0, r); + } + /** + * @internal + */ + _uploadDataToTextureDirectly(e, t, i = 0, s = 0, r, n = !1) { + const a = this._gl, o = this._getWebGLTextureType(e.type), h = this._getInternalFormat(e.format), c = r === void 0 ? this._getRGBABufferInternalSizedFormat(e.type, e.format, e._useSRGBBuffer) : this._getInternalFormat(r, e._useSRGBBuffer); + this._unpackFlipY(e.invertY); + let u = a.TEXTURE_2D; + e.isCube && (u = a.TEXTURE_CUBE_MAP_POSITIVE_X + i); + const d = Math.round(Math.log(e.width) * Math.LOG2E), g = Math.round(Math.log(e.height) * Math.LOG2E), f = n ? e.width : Math.pow(2, Math.max(d - s, 0)), m = n ? e.height : Math.pow(2, Math.max(g - s, 0)); + a.texImage2D(u, s, c, f, m, 0, h, o, t); + } + /** + * Update a portion of an internal texture + * @param texture defines the texture to update + * @param imageData defines the data to store into the texture + * @param xOffset defines the x coordinates of the update rectangle + * @param yOffset defines the y coordinates of the update rectangle + * @param width defines the width of the update rectangle + * @param height defines the height of the update rectangle + * @param faceIndex defines the face index if texture is a cube (0 by default) + * @param lod defines the lod level to update (0 by default) + * @param generateMipMaps defines whether to generate mipmaps or not + */ + updateTextureData(e, t, i, s, r, n, a = 0, o = 0, h = !1) { + const c = this._gl, u = this._getWebGLTextureType(e.type), d = this._getInternalFormat(e.format); + this._unpackFlipY(e.invertY); + let g = c.TEXTURE_2D, f = c.TEXTURE_2D; + e.isCube && (f = c.TEXTURE_CUBE_MAP_POSITIVE_X + a, g = c.TEXTURE_CUBE_MAP), this._bindTextureDirectly(g, e, !0), c.texSubImage2D(f, o, i, s, r, n, d, u, t), h && this._gl.generateMipmap(f), this._bindTextureDirectly(g, null); + } + /** + * @internal + */ + _uploadArrayBufferViewToTexture(e, t, i = 0, s = 0) { + const r = this._gl, n = e.isCube ? r.TEXTURE_CUBE_MAP : r.TEXTURE_2D; + this._bindTextureDirectly(n, e, !0), this._uploadDataToTextureDirectly(e, t, i, s), this._bindTextureDirectly(n, null, !0); + } + _prepareWebGLTextureContinuation(e, t, i, s, r) { + const n = this._gl; + if (!n) + return; + const a = this._getSamplingParameters(r, !i); + n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, a.mag), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, a.min), !i && !s && n.generateMipmap(n.TEXTURE_2D), this._bindTextureDirectly(n.TEXTURE_2D, null), t && t.removePendingData(e), e.onLoadedObservable.notifyObservers(e), e.onLoadedObservable.clear(); + } + _prepareWebGLTexture(e, t, i, s, r, n, a, o, h = 3) { + const c = this.getCaps().maxTextureSize, u = Math.min(c, this.needPOTTextures ? se.GetExponentOfTwo(s.width, c) : s.width), d = Math.min(c, this.needPOTTextures ? se.GetExponentOfTwo(s.height, c) : s.height), g = this._gl; + if (g) { + if (!e._hardwareTexture) { + i && i.removePendingData(e); + return; + } + this._bindTextureDirectly(g.TEXTURE_2D, e, !0), this._unpackFlipY(r === void 0 ? !0 : !!r), e.baseWidth = s.width, e.baseHeight = s.height, e.width = u, e.height = d, e.isReady = !0, !o(u, d, s, t, e, () => { + this._prepareWebGLTextureContinuation(e, i, n, a, h); + }) && this._prepareWebGLTextureContinuation(e, i, n, a, h); + } + } + /** + * @internal + */ + _setupFramebufferDepthAttachments(e, t, i, s, r = 1) { + const n = this._gl; + if (e && t) + return this._createRenderBuffer(i, s, r, n.DEPTH_STENCIL, n.DEPTH24_STENCIL8, n.DEPTH_STENCIL_ATTACHMENT); + if (t) { + let a = n.DEPTH_COMPONENT16; + return this._webGLVersion > 1 && (a = n.DEPTH_COMPONENT32F), this._createRenderBuffer(i, s, r, a, a, n.DEPTH_ATTACHMENT); + } + return e ? this._createRenderBuffer(i, s, r, n.STENCIL_INDEX8, n.STENCIL_INDEX8, n.STENCIL_ATTACHMENT) : null; + } + /** + * @internal + */ + _createRenderBuffer(e, t, i, s, r, n, a = !0) { + const h = this._gl.createRenderbuffer(); + return this._updateRenderBuffer(h, e, t, i, s, r, n, a); + } + _updateRenderBuffer(e, t, i, s, r, n, a, o = !0) { + const h = this._gl; + return h.bindRenderbuffer(h.RENDERBUFFER, e), s > 1 && h.renderbufferStorageMultisample ? h.renderbufferStorageMultisample(h.RENDERBUFFER, s, n, t, i) : h.renderbufferStorage(h.RENDERBUFFER, r, t, i), h.framebufferRenderbuffer(h.FRAMEBUFFER, a, h.RENDERBUFFER, e), o && h.bindRenderbuffer(h.RENDERBUFFER, null), e; + } + /** + * @internal + */ + _releaseTexture(e) { + var t; + this._deleteTexture((t = e._hardwareTexture) === null || t === void 0 ? void 0 : t.underlyingResource), this.unbindAllTextures(); + const i = this._internalTexturesCache.indexOf(e); + i !== -1 && this._internalTexturesCache.splice(i, 1), e._lodTextureHigh && e._lodTextureHigh.dispose(), e._lodTextureMid && e._lodTextureMid.dispose(), e._lodTextureLow && e._lodTextureLow.dispose(), e._irradianceTexture && e._irradianceTexture.dispose(); + } + /** + * @internal + */ + _releaseRenderTargetWrapper(e) { + const t = this._renderTargetWrapperCache.indexOf(e); + t !== -1 && this._renderTargetWrapperCache.splice(t, 1); + } + _deleteTexture(e) { + e && this._gl.deleteTexture(e); + } + _setProgram(e) { + this._currentProgram !== e && (this._gl.useProgram(e), this._currentProgram = e); + } + /** + * Binds an effect to the webGL context + * @param effect defines the effect to bind + */ + bindSamplers(e) { + const t = e.getPipelineContext(); + this._setProgram(t.program); + const i = e.getSamplers(); + for (let s = 0; s < i.length; s++) { + const r = e.getUniform(i[s]); + r && (this._boundUniforms[s] = r); + } + this._currentEffect = null; + } + _activateCurrentTexture() { + this._currentTextureChannel !== this._activeChannel && (this._gl.activeTexture(this._gl.TEXTURE0 + this._activeChannel), this._currentTextureChannel = this._activeChannel); + } + /** + * @internal + */ + _bindTextureDirectly(e, t, i = !1, s = !1) { + var r, n; + let a = !1; + const o = t && t._associatedChannel > -1; + if (i && o && (this._activeChannel = t._associatedChannel), this._boundTexturesCache[this._activeChannel] !== t || s) { + if (this._activateCurrentTexture(), t && t.isMultiview) + throw console.error(e, t), "_bindTextureDirectly called with a multiview texture!"; + this._gl.bindTexture(e, (n = (r = t == null ? void 0 : t._hardwareTexture) === null || r === void 0 ? void 0 : r.underlyingResource) !== null && n !== void 0 ? n : null), this._boundTexturesCache[this._activeChannel] = t, t && (t._associatedChannel = this._activeChannel); + } else + i && (a = !0, this._activateCurrentTexture()); + return o && !i && this._bindSamplerUniformToChannel(t._associatedChannel, this._activeChannel), a; + } + /** + * @internal + */ + _bindTexture(e, t, i) { + if (e === void 0) + return; + t && (t._associatedChannel = e), this._activeChannel = e; + const s = t ? this._getTextureTarget(t) : this._gl.TEXTURE_2D; + this._bindTextureDirectly(s, t); + } + /** + * Unbind all textures from the webGL context + */ + unbindAllTextures() { + for (let e = 0; e < this._maxSimultaneousTextures; e++) + this._activeChannel = e, this._bindTextureDirectly(this._gl.TEXTURE_2D, null), this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null), this.webGLVersion > 1 && (this._bindTextureDirectly(this._gl.TEXTURE_3D, null), this._bindTextureDirectly(this._gl.TEXTURE_2D_ARRAY, null)); + } + /** + * Sets a texture to the according uniform. + * @param channel The texture channel + * @param uniform The uniform to set + * @param texture The texture to apply + * @param name The name of the uniform in the effect + */ + setTexture(e, t, i, s) { + e !== void 0 && (t && (this._boundUniforms[e] = t), this._setTexture(e, i)); + } + _bindSamplerUniformToChannel(e, t) { + const i = this._boundUniforms[e]; + !i || i._currentState === t || (this._gl.uniform1i(i, t), i._currentState = t); + } + _getTextureWrapMode(e) { + switch (e) { + case 1: + return this._gl.REPEAT; + case 0: + return this._gl.CLAMP_TO_EDGE; + case 2: + return this._gl.MIRRORED_REPEAT; + } + return this._gl.REPEAT; + } + _setTexture(e, t, i = !1, s = !1, r = "") { + if (!t) + return this._boundTexturesCache[e] != null && (this._activeChannel = e, this._bindTextureDirectly(this._gl.TEXTURE_2D, null), this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null), this.webGLVersion > 1 && (this._bindTextureDirectly(this._gl.TEXTURE_3D, null), this._bindTextureDirectly(this._gl.TEXTURE_2D_ARRAY, null))), !1; + if (t.video) + this._activeChannel = e, t.update(); + else if (t.delayLoadState === 4) + return t.delayLoad(), !1; + let n; + s ? n = t.depthStencilTexture : t.isReady() ? n = t.getInternalTexture() : t.isCube ? n = this.emptyCubeTexture : t.is3D ? n = this.emptyTexture3D : t.is2DArray ? n = this.emptyTexture2DArray : n = this.emptyTexture, !i && n && (n._associatedChannel = e); + let a = !0; + this._boundTexturesCache[e] === n && (i || this._bindSamplerUniformToChannel(n._associatedChannel, e), a = !1), this._activeChannel = e; + const o = this._getTextureTarget(n); + if (a && this._bindTextureDirectly(o, n, i), n && !n.isMultiview) { + if (n.isCube && n._cachedCoordinatesMode !== t.coordinatesMode) { + n._cachedCoordinatesMode = t.coordinatesMode; + const h = t.coordinatesMode !== 3 && t.coordinatesMode !== 5 ? 1 : 0; + t.wrapU = h, t.wrapV = h; + } + n._cachedWrapU !== t.wrapU && (n._cachedWrapU = t.wrapU, this._setTextureParameterInteger(o, this._gl.TEXTURE_WRAP_S, this._getTextureWrapMode(t.wrapU), n)), n._cachedWrapV !== t.wrapV && (n._cachedWrapV = t.wrapV, this._setTextureParameterInteger(o, this._gl.TEXTURE_WRAP_T, this._getTextureWrapMode(t.wrapV), n)), n.is3D && n._cachedWrapR !== t.wrapR && (n._cachedWrapR = t.wrapR, this._setTextureParameterInteger(o, this._gl.TEXTURE_WRAP_R, this._getTextureWrapMode(t.wrapR), n)), this._setAnisotropicLevel(o, n, t.anisotropicFilteringLevel); + } + return !0; + } + /** + * Sets an array of texture to the webGL context + * @param channel defines the channel where the texture array must be set + * @param uniform defines the associated uniform location + * @param textures defines the array of textures to bind + * @param name name of the channel + */ + setTextureArray(e, t, i, s) { + if (!(e === void 0 || !t)) { + (!this._textureUnits || this._textureUnits.length !== i.length) && (this._textureUnits = new Int32Array(i.length)); + for (let r = 0; r < i.length; r++) { + const n = i[r].getInternalTexture(); + n ? (this._textureUnits[r] = e + r, n._associatedChannel = e + r) : this._textureUnits[r] = -1; + } + this._gl.uniform1iv(t, this._textureUnits); + for (let r = 0; r < i.length; r++) + this._setTexture(this._textureUnits[r], i[r], !0); + } + } + /** + * @internal + */ + _setAnisotropicLevel(e, t, i) { + const s = this._caps.textureAnisotropicFilterExtension; + t.samplingMode !== 11 && t.samplingMode !== 3 && t.samplingMode !== 2 && (i = 1), s && t._cachedAnisotropicFilteringLevel !== i && (this._setTextureParameterFloat(e, s.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(i, this._caps.maxAnisotropy), t), t._cachedAnisotropicFilteringLevel = i); + } + _setTextureParameterFloat(e, t, i, s) { + this._bindTextureDirectly(e, s, !0, !0), this._gl.texParameterf(e, t, i); + } + _setTextureParameterInteger(e, t, i, s) { + s && this._bindTextureDirectly(e, s, !0, !0), this._gl.texParameteri(e, t, i); + } + /** + * Unbind all vertex attributes from the webGL context + */ + unbindAllAttributes() { + if (this._mustWipeVertexAttributes) { + this._mustWipeVertexAttributes = !1; + for (let e = 0; e < this._caps.maxVertexAttribs; e++) + this.disableAttributeByIndex(e); + return; + } + for (let e = 0, t = this._vertexAttribArraysEnabled.length; e < t; e++) + e >= this._caps.maxVertexAttribs || !this._vertexAttribArraysEnabled[e] || this.disableAttributeByIndex(e); + } + /** + * Force the engine to release all cached effects. This means that next effect compilation will have to be done completely even if a similar effect was already compiled + */ + releaseEffects() { + for (const e in this._compiledEffects) { + const t = this._compiledEffects[e].getPipelineContext(); + this._deletePipelineContext(t); + } + this._compiledEffects = {}; + } + /** + * Dispose and release all associated resources + */ + dispose() { + var e; + this._isDisposed = !0, this.stopRenderLoop(), this.onBeforeTextureInitObservable && this.onBeforeTextureInitObservable.clear(), this._emptyTexture && (this._releaseTexture(this._emptyTexture), this._emptyTexture = null), this._emptyCubeTexture && (this._releaseTexture(this._emptyCubeTexture), this._emptyCubeTexture = null), this._dummyFramebuffer && this._gl.deleteFramebuffer(this._dummyFramebuffer), this.releaseEffects(), (e = this.releaseComputeEffects) === null || e === void 0 || e.call(this), this.unbindAllAttributes(), this._boundUniforms = {}, Ie() && this._renderingCanvas && (this._doNotHandleContextLost || (this._renderingCanvas.removeEventListener("webglcontextlost", this._onContextLost), this._renderingCanvas.removeEventListener("webglcontextrestored", this._onContextRestored)), window.removeEventListener("resize", this._checkForMobile)), this._workingCanvas = null, this._workingContext = null, this._currentBufferPointers.length = 0, this._renderingCanvas = null, this._currentProgram = null, this._boundRenderFunction = null, Be.ResetCache(); + for (const t of this._activeRequests) + t.abort(); + this.onDisposeObservable.notifyObservers(this), this.onDisposeObservable.clear(); + } + /** + * Attach a new callback raised when context lost event is fired + * @param callback defines the callback to call + */ + attachContextLostEvent(e) { + this._renderingCanvas && this._renderingCanvas.addEventListener("webglcontextlost", e, !1); + } + /** + * Attach a new callback raised when context restored event is fired + * @param callback defines the callback to call + */ + attachContextRestoredEvent(e) { + this._renderingCanvas && this._renderingCanvas.addEventListener("webglcontextrestored", e, !1); + } + /** + * Get the current error code of the webGL context + * @returns the error code + * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getError + */ + getError() { + return this._gl.getError(); + } + _canRenderToFloatFramebuffer() { + return this._webGLVersion > 1 ? this._caps.colorBufferFloat : this._canRenderToFramebuffer(1); + } + _canRenderToHalfFloatFramebuffer() { + return this._webGLVersion > 1 ? this._caps.colorBufferFloat : this._canRenderToFramebuffer(2); + } + // Thank you : http://stackoverflow.com/questions/28827511/webgl-ios-render-to-floating-point-texture + _canRenderToFramebuffer(e) { + const t = this._gl; + for (; t.getError() !== t.NO_ERROR; ) + ; + let i = !0; + const s = t.createTexture(); + t.bindTexture(t.TEXTURE_2D, s), t.texImage2D(t.TEXTURE_2D, 0, this._getRGBABufferInternalSizedFormat(e), 1, 1, 0, t.RGBA, this._getWebGLTextureType(e), null), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.NEAREST); + const r = t.createFramebuffer(); + t.bindFramebuffer(t.FRAMEBUFFER, r), t.framebufferTexture2D(t.FRAMEBUFFER, t.COLOR_ATTACHMENT0, t.TEXTURE_2D, s, 0); + const n = t.checkFramebufferStatus(t.FRAMEBUFFER); + if (i = i && n === t.FRAMEBUFFER_COMPLETE, i = i && t.getError() === t.NO_ERROR, i && (t.clear(t.COLOR_BUFFER_BIT), i = i && t.getError() === t.NO_ERROR), i) { + t.bindFramebuffer(t.FRAMEBUFFER, null); + const a = t.RGBA, o = t.UNSIGNED_BYTE, h = new Uint8Array(4); + t.readPixels(0, 0, 1, 1, a, o, h), i = i && t.getError() === t.NO_ERROR; + } + for (t.deleteTexture(s), t.deleteFramebuffer(r), t.bindFramebuffer(t.FRAMEBUFFER, null); !i && t.getError() !== t.NO_ERROR; ) + ; + return i; + } + /** + * @internal + */ + _getWebGLTextureType(e) { + if (this._webGLVersion === 1) { + switch (e) { + case 1: + return this._gl.FLOAT; + case 2: + return this._gl.HALF_FLOAT_OES; + case 0: + return this._gl.UNSIGNED_BYTE; + case 8: + return this._gl.UNSIGNED_SHORT_4_4_4_4; + case 9: + return this._gl.UNSIGNED_SHORT_5_5_5_1; + case 10: + return this._gl.UNSIGNED_SHORT_5_6_5; + } + return this._gl.UNSIGNED_BYTE; + } + switch (e) { + case 3: + return this._gl.BYTE; + case 0: + return this._gl.UNSIGNED_BYTE; + case 4: + return this._gl.SHORT; + case 5: + return this._gl.UNSIGNED_SHORT; + case 6: + return this._gl.INT; + case 7: + return this._gl.UNSIGNED_INT; + case 1: + return this._gl.FLOAT; + case 2: + return this._gl.HALF_FLOAT; + case 8: + return this._gl.UNSIGNED_SHORT_4_4_4_4; + case 9: + return this._gl.UNSIGNED_SHORT_5_5_5_1; + case 10: + return this._gl.UNSIGNED_SHORT_5_6_5; + case 11: + return this._gl.UNSIGNED_INT_2_10_10_10_REV; + case 12: + return this._gl.UNSIGNED_INT_24_8; + case 13: + return this._gl.UNSIGNED_INT_10F_11F_11F_REV; + case 14: + return this._gl.UNSIGNED_INT_5_9_9_9_REV; + case 15: + return this._gl.FLOAT_32_UNSIGNED_INT_24_8_REV; + } + return this._gl.UNSIGNED_BYTE; + } + /** + * @internal + */ + _getInternalFormat(e, t = !1) { + let i = t ? this._gl.SRGB8_ALPHA8 : this._gl.RGBA; + switch (e) { + case 0: + i = this._gl.ALPHA; + break; + case 1: + i = this._gl.LUMINANCE; + break; + case 2: + i = this._gl.LUMINANCE_ALPHA; + break; + case 6: + i = this._gl.RED; + break; + case 7: + i = this._gl.RG; + break; + case 4: + i = t ? this._gl.SRGB : this._gl.RGB; + break; + case 5: + i = t ? this._gl.SRGB8_ALPHA8 : this._gl.RGBA; + break; + } + if (this._webGLVersion > 1) + switch (e) { + case 8: + i = this._gl.RED_INTEGER; + break; + case 9: + i = this._gl.RG_INTEGER; + break; + case 10: + i = this._gl.RGB_INTEGER; + break; + case 11: + i = this._gl.RGBA_INTEGER; + break; + } + return i; + } + /** + * @internal + */ + _getRGBABufferInternalSizedFormat(e, t, i = !1) { + if (this._webGLVersion === 1) { + if (t !== void 0) + switch (t) { + case 0: + return this._gl.ALPHA; + case 1: + return this._gl.LUMINANCE; + case 2: + return this._gl.LUMINANCE_ALPHA; + case 4: + return i ? this._gl.SRGB : this._gl.RGB; + } + return this._gl.RGBA; + } + switch (e) { + case 3: + switch (t) { + case 6: + return this._gl.R8_SNORM; + case 7: + return this._gl.RG8_SNORM; + case 4: + return this._gl.RGB8_SNORM; + case 8: + return this._gl.R8I; + case 9: + return this._gl.RG8I; + case 10: + return this._gl.RGB8I; + case 11: + return this._gl.RGBA8I; + default: + return this._gl.RGBA8_SNORM; + } + case 0: + switch (t) { + case 6: + return this._gl.R8; + case 7: + return this._gl.RG8; + case 4: + return i ? this._gl.SRGB8 : this._gl.RGB8; + case 5: + return i ? this._gl.SRGB8_ALPHA8 : this._gl.RGBA8; + case 8: + return this._gl.R8UI; + case 9: + return this._gl.RG8UI; + case 10: + return this._gl.RGB8UI; + case 11: + return this._gl.RGBA8UI; + case 0: + return this._gl.ALPHA; + case 1: + return this._gl.LUMINANCE; + case 2: + return this._gl.LUMINANCE_ALPHA; + default: + return this._gl.RGBA8; + } + case 4: + switch (t) { + case 8: + return this._gl.R16I; + case 9: + return this._gl.RG16I; + case 10: + return this._gl.RGB16I; + case 11: + return this._gl.RGBA16I; + default: + return this._gl.RGBA16I; + } + case 5: + switch (t) { + case 8: + return this._gl.R16UI; + case 9: + return this._gl.RG16UI; + case 10: + return this._gl.RGB16UI; + case 11: + return this._gl.RGBA16UI; + default: + return this._gl.RGBA16UI; + } + case 6: + switch (t) { + case 8: + return this._gl.R32I; + case 9: + return this._gl.RG32I; + case 10: + return this._gl.RGB32I; + case 11: + return this._gl.RGBA32I; + default: + return this._gl.RGBA32I; + } + case 7: + switch (t) { + case 8: + return this._gl.R32UI; + case 9: + return this._gl.RG32UI; + case 10: + return this._gl.RGB32UI; + case 11: + return this._gl.RGBA32UI; + default: + return this._gl.RGBA32UI; + } + case 1: + switch (t) { + case 6: + return this._gl.R32F; + case 7: + return this._gl.RG32F; + case 4: + return this._gl.RGB32F; + case 5: + return this._gl.RGBA32F; + default: + return this._gl.RGBA32F; + } + case 2: + switch (t) { + case 6: + return this._gl.R16F; + case 7: + return this._gl.RG16F; + case 4: + return this._gl.RGB16F; + case 5: + return this._gl.RGBA16F; + default: + return this._gl.RGBA16F; + } + case 10: + return this._gl.RGB565; + case 13: + return this._gl.R11F_G11F_B10F; + case 14: + return this._gl.RGB9_E5; + case 8: + return this._gl.RGBA4; + case 9: + return this._gl.RGB5_A1; + case 11: + switch (t) { + case 5: + return this._gl.RGB10_A2; + case 11: + return this._gl.RGB10_A2UI; + default: + return this._gl.RGB10_A2; + } + } + return i ? this._gl.SRGB8_ALPHA8 : this._gl.RGBA8; + } + /** + * @internal + */ + _getRGBAMultiSampleBufferFormat(e) { + return e === 1 ? this._gl.RGBA32F : e === 2 ? this._gl.RGBA16F : this._gl.RGBA8; + } + /** + * @internal + */ + _loadFile(e, t, i, s, r, n) { + const a = se._FileToolsLoadFile(e, t, i, s, r, n); + return this._activeRequests.push(a), a.onCompleteObservable.add((o) => { + this._activeRequests.splice(this._activeRequests.indexOf(o), 1); + }), a; + } + /** + * Loads a file from a url + * @param url url to load + * @param onSuccess callback called when the file successfully loads + * @param onProgress callback called while file is loading (if the server supports this mode) + * @param offlineProvider defines the offline provider for caching + * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer + * @param onError callback called when the file fails to load + * @returns a file request object + * @internal + */ + static _FileToolsLoadFile(e, t, i, s, r, n) { + throw Y("FileTools"); + } + /** + * Reads pixels from the current frame buffer. Please note that this function can be slow + * @param x defines the x coordinate of the rectangle where pixels must be read + * @param y defines the y coordinate of the rectangle where pixels must be read + * @param width defines the width of the rectangle where pixels must be read + * @param height defines the height of the rectangle where pixels must be read + * @param hasAlpha defines whether the output should have alpha or not (defaults to true) + * @param flushRenderer true to flush the renderer from the pending commands before reading the pixels + * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors + */ + readPixels(e, t, i, s, r = !0, n = !0) { + const a = r ? 4 : 3, o = r ? this._gl.RGBA : this._gl.RGB, h = new Uint8Array(s * i * a); + return n && this.flushFramebuffer(), this._gl.readPixels(e, t, i, s, o, this._gl.UNSIGNED_BYTE, h), Promise.resolve(h); + } + /** + * Gets a Promise
Dice-Tower
+Welcome to Dice-Tower
++
+
+
+
+ + +
+ +
+
+
+
+
++ + +
+ +
+
+
Example Commands: "1d6", "2d8 1d100", "5d6+10"
++
+
+
+
+
+
+