@vived/component-abb-6700 1.0.0

package/dist/thinEngine-Bt9FW4dD.js

@@ -0,0 +1,2425 @@
+import { G as X, f as w, I as O, bR as U, a7 as I, bY as L, h as W, c5 as k, bn as K, bO as j, bP as Y, bN as z, bF as Q, bH as Z, bD as $, bG as q, bE as J, a4 as ee, a1 as y, X as N, bI as te, a3 as re, bl as se } from "./index-CS3Icp_r.js";
+class ie {
+  constructor() {
+    this.shaderLanguage = 0;
+  }
+  postProcessor(e, t, r, s, i) {
+    if (i.drawBuffersExtensionDisabled) {
+      const n = /#extension.+GL_EXT_draw_buffers.+(enable|require)/g;
+      e = e.replace(n, "");
+    }
+    return e;
+  }
+}
+const ne = /(flat\s)?\s*varying\s*.*/;
+class ae {
+  constructor() {
+    this.shaderLanguage = 0;
+  }
+  attributeProcessor(e) {
+    return e.replace("attribute", "in");
+  }
+  varyingCheck(e, t) {
+    return ne.test(e);
+  }
+  varyingProcessor(e, t) {
+    return e.replace("varying", t ? "in" : "out");
+  }
+  postProcessor(e, t, r) {
+    const s = e.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1, i = /#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(i, ""), e = e.replace(/texture2D\s*\(/g, "texture("), r) {
+      const n = e.search(/layout *\(location *= *0\) *out/g) !== -1, l = t.indexOf("#define DUAL_SOURCE_BLENDING") !== -1, a = l ? `layout(location = 0, index = 0) out vec4 glFragColor;
+layout(location = 0, index = 1) out vec4 glFragColor2;
+` : `layout(location = 0) out vec4 glFragColor;
+`;
+      l && (e = `#extension GL_EXT_blend_func_extended : require
+` + e), 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 || n ? "" : a) + "void main(");
+    } else if (t.indexOf("#define VERTEXOUTPUT_INVARIANT") >= 0 && (e = `invariant gl_Position;
+` + e), t.indexOf("#define MULTIVIEW") !== -1)
+      return `#extension GL_OVR_multiview2 : require
+layout (num_views = 2) in;
+` + e;
+    return e;
+  }
+}
+class v extends X {
+  /** @internal */
+  constructor(e) {
+    super(), this._buffer = e;
+  }
+  /** @internal */
+  get underlyingResource() {
+    return this._buffer;
+  }
+}
+class _e {
+  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;
+    }
+  }
+  getMSAARenderBuffer(e = 0) {
+    return this._MSAARenderBuffers?.[e] ?? null;
+  }
+  release() {
+    this.releaseMSAARenderBuffers(), this._webGLTexture && this._context.deleteTexture(this._webGLTexture), this.reset();
+  }
+}
+function H(R) {
+  return R === 13 || R === 14 || R === 15 || R === 16 || R === 17 || R === 18 || R === 19;
+}
+function V(R) {
+  return R === 13 || R === 17 || R === 18 || R === 19;
+}
+class le {
+}
+class T extends w {
+  /**
+   * 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;
+  }
+  /**
+   * Gets or sets the relative url used to load shaders if using the engine in non-minified mode
+   */
+  static get ShadersRepository() {
+    return O.ShadersRepository;
+  }
+  static set ShadersRepository(e) {
+    O.ShadersRepository = e;
+  }
+  /**
+   * 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 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;
+  }
+  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;
+  }
+  /**
+   * Creates a new snapshot at the next frame using the current snapshotRenderingMode
+   */
+  snapshotRenderingReset() {
+    this.snapshotRendering = !1;
+  }
+  /**
+   * 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 whether anti-aliasing should be enabled (default value is "undefined", meaning that the browser may or may not enable it)
+   * @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, r, s) {
+    if (r = r || {}, super(t ?? r.antialias, r, s), this._name = "WebGL", this.forcePOTTextures = !1, this.validateShaderPrograms = !1, this.disableUniformBuffers = !1, this._webGLVersion = 1, 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._unpackFlipYCached = null, this.enableUnpackFlipYCached = !0, this._boundUniforms = {}, !e)
+      return;
+    let i;
+    if (e.getContext) {
+      if (i = e, r.preserveDrawingBuffer === void 0 && (r.preserveDrawingBuffer = !1), r.xrCompatible === void 0 && (r.xrCompatible = !1), navigator && navigator.userAgent) {
+        this._setupMobileChecks();
+        const a = navigator.userAgent;
+        for (const _ of T.ExceptionList) {
+          const u = _.key, f = _.targets;
+          if (new RegExp(u).test(a)) {
+            if (_.capture && _.captureConstraint) {
+              const d = _.capture, g = _.captureConstraint, E = new RegExp(d).exec(a);
+              if (E && E.length > 0 && parseInt(E[E.length - 1]) >= g)
+                continue;
+            }
+            for (const d of f)
+              switch (d) {
+                case "uniformBuffer":
+                  this.disableUniformBuffers = !0;
+                  break;
+                case "vao":
+                  this.disableVertexArrayObjects = !0;
+                  break;
+                case "antialias":
+                  r.antialias = !1;
+                  break;
+                case "maxMSAASamples":
+                  this._maxMSAASamplesOverride = 1;
+                  break;
+              }
+          }
+        }
+      }
+      if (this._doNotHandleContextLost ? this._onContextLost = () => {
+        U(this._gl);
+      } : (this._onContextLost = (a) => {
+        a.preventDefault(), this._contextWasLost = !0, U(this._gl), I.Warn("WebGL context lost."), this.onContextLostObservable.notifyObservers(this);
+      }, this._onContextRestored = () => {
+        this._restoreEngineAfterContextLost(() => this._initGLContext());
+      }, i.addEventListener("webglcontextrestored", this._onContextRestored, !1), r.powerPreference = r.powerPreference || "high-performance"), i.addEventListener("webglcontextlost", this._onContextLost, !1), this._badDesktopOS && (r.xrCompatible = !1), !r.disableWebGL2Support)
+        try {
+          this._gl = i.getContext("webgl2", r) || i.getContext("experimental-webgl2", r), this._gl && (this._webGLVersion = 2, this._shaderPlatformName = "WEBGL2", this._gl.deleteQuery || (this._webGLVersion = 1, this._shaderPlatformName = "WEBGL1"));
+        } catch {
+        }
+      if (!this._gl) {
+        if (!i)
+          throw new Error("The provided canvas is null or undefined.");
+        try {
+          this._gl = i.getContext("webgl", r) || i.getContext("experimental-webgl", r);
+        } catch (a) {
+          throw new Error("WebGL not supported", { cause: a });
+        }
+      }
+      if (!this._gl)
+        throw new Error("WebGL not supported");
+    } else {
+      this._gl = e, i = this._gl.canvas, this._gl.renderbufferStorageMultisample ? (this._webGLVersion = 2, this._shaderPlatformName = "WEBGL2") : this._shaderPlatformName = "WEBGL1";
+      const a = this._gl.getContextAttributes();
+      a && (r.stencil = a.stencil);
+    }
+    this._sharedInit(i), this._gl.pixelStorei(this._gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, this._gl.NONE), r.useHighPrecisionFloats !== void 0 && (this._highPrecisionShadersAllowed = r.useHighPrecisionFloats), this.resize(), this._initGLContext(), this._initFeatures();
+    for (let a = 0; a < this._caps.maxVertexAttribs; a++)
+      this._currentBufferPointers[a] = new le();
+    this._shaderProcessor = this.webGLVersion > 1 ? new ae() : new ie();
+    const n = `Babylon.js v${T.Version}`;
+    I.Log(n + ` - ${this.description}`), this._renderingCanvas && this._renderingCanvas.setAttribute && this._renderingCanvas.setAttribute("data-engine", n);
+    const l = L(this._gl);
+    l.validateShaderPrograms = this.validateShaderPrograms, l.parallelShaderCompile = this._caps.parallelShaderCompile;
+  }
+  _clearEmptyResources() {
+    this._dummyFramebuffer = null, super._clearEmptyResources();
+  }
+  /**
+   * @internal
+   */
+  _getShaderProcessingContext(e) {
+    return null;
+  }
+  /**
+   * 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;
+  }
+  _initGLContext() {
+    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),
+      shaderFloatPrecision: 0,
+      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"),
+      // also a requirement of OpenGL ES 3
+      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")),
+      blendFloat: this._gl.getExtension("EXT_float_blend") !== null,
+      supportFloatTexturesResolve: !1,
+      rg11b10ufColorRenderable: !1,
+      colorBufferHalfFloat: !!(this._webGLVersion > 1 && this._gl.getExtension("EXT_color_buffer_half_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,
+      textureNorm16: !!this._gl.getExtension("EXT_texture_norm16"),
+      blendParametersPerTarget: !1,
+      dualSourceBlending: !1,
+      supportReadWriteStorageTextures: !1
+    }, this._caps.supportFloatTexturesResolve = this._caps.colorBufferFloat, this._caps.rg11b10ufColorRenderable = this._caps.colorBufferFloat, this._glVersion = this._gl.getParameter(this._gl.VERSION);
+    const e = this._gl.getExtension("WEBGL_debug_renderer_info");
+    e != null && (this._glRenderer = this._gl.getParameter(e.UNMASKED_RENDERER_WEBGL), this._glVendor = this._gl.getParameter(e.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 = (this._gl.getQuery(this._caps.timerQuery.TIMESTAMP_EXT, this._caps.timerQuery.QUERY_COUNTER_BITS_EXT) ?? 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.textureNorm16 && (this._gl.R16_EXT = 33322, this._gl.RG16_EXT = 33324, this._gl.RGB16_EXT = 32852, this._gl.RGBA16_EXT = 32859, this._gl.R16_SNORM_EXT = 36760, this._gl.RG16_SNORM_EXT = 36761, this._gl.RGB16_SNORM_EXT = 36762, this._gl.RGBA16_SNORM_EXT = 36763);
+    const t = this._gl.getExtension("OES_draw_buffers_indexed");
+    if (this._caps.blendParametersPerTarget = !!t, this._alphaState = new W(this._caps.blendParametersPerTarget), t && (this._gl.blendEquationSeparateIndexed = t.blendEquationSeparateiOES.bind(t), this._gl.blendEquationIndexed = t.blendEquationiOES.bind(t), this._gl.blendFuncSeparateIndexed = t.blendFuncSeparateiOES.bind(t), this._gl.blendFuncIndexed = t.blendFunciOES.bind(t), this._gl.colorMaskIndexed = t.colorMaskiOES.bind(t), this._gl.disableIndexed = t.disableiOES.bind(t), this._gl.enableIndexed = t.enableiOES.bind(t)), this._caps.dualSourceBlending = !!this._gl.getExtension("WEBGL_blend_func_extended"), this._caps.astc && (this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_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), this._caps.maxDrawBuffers = this._gl.getParameter(this._gl.MAX_DRAW_BUFFERS);
+    else {
+      const r = this._gl.getExtension("WEBGL_draw_buffers");
+      if (r !== null) {
+        this._caps.drawBuffersExtension = !0, this._gl.drawBuffers = r.drawBuffersWEBGL.bind(r), this._caps.maxDrawBuffers = this._gl.getParameter(r.MAX_DRAW_BUFFERS_WEBGL), this._gl.DRAW_FRAMEBUFFER = this._gl.FRAMEBUFFER;
+        for (let s = 0; s < 16; s++)
+          this._gl["COLOR_ATTACHMENT" + s + "_WEBGL"] = r["COLOR_ATTACHMENT" + s + "_WEBGL"];
+      }
+    }
+    if (this._webGLVersion > 1)
+      this._caps.depthTextureExtension = !0;
+    else {
+      const r = this._gl.getExtension("WEBGL_depth_texture");
+      r != null && (this._caps.depthTextureExtension = !0, this._gl.UNSIGNED_INT_24_8 = r.UNSIGNED_INT_24_8_WEBGL);
+    }
+    if (this.disableVertexArrayObjects)
+      this._caps.vertexArrayObject = !1;
+    else if (this._webGLVersion > 1)
+      this._caps.vertexArrayObject = !0;
+    else {
+      const r = this._gl.getExtension("OES_vertex_array_object");
+      r != null && (this._caps.vertexArrayObject = !0, this._gl.createVertexArray = r.createVertexArrayOES.bind(r), this._gl.bindVertexArray = r.bindVertexArrayOES.bind(r), this._gl.deleteVertexArray = r.deleteVertexArrayOES.bind(r));
+    }
+    if (this._webGLVersion > 1)
+      this._caps.instancedArrays = !0;
+    else {
+      const r = this._gl.getExtension("ANGLE_instanced_arrays");
+      r != null ? (this._caps.instancedArrays = !0, this._gl.drawArraysInstanced = r.drawArraysInstancedANGLE.bind(r), this._gl.drawElementsInstanced = r.drawElementsInstancedANGLE.bind(r), this._gl.vertexAttribDivisor = r.vertexAttribDivisorANGLE.bind(r)) : this._caps.instancedArrays = !1;
+    }
+    if (this._gl.getShaderPrecisionFormat) {
+      const r = this._gl.getShaderPrecisionFormat(this._gl.VERTEX_SHADER, this._gl.HIGH_FLOAT), s = this._gl.getShaderPrecisionFormat(this._gl.FRAGMENT_SHADER, this._gl.HIGH_FLOAT);
+      if (r && s && (this._caps.highPrecisionShaderSupported = r.precision !== 0 && s.precision !== 0, this._caps.shaderFloatPrecision = Math.min(r.precision, s.precision)), !this._shouldUseHighPrecisionShader) {
+        const i = this._gl.getShaderPrecisionFormat(this._gl.VERTEX_SHADER, this._gl.MEDIUM_FLOAT), n = this._gl.getShaderPrecisionFormat(this._gl.FRAGMENT_SHADER, this._gl.MEDIUM_FLOAT);
+        i && n && (this._caps.shaderFloatPrecision = Math.min(i.precision, n.precision));
+      }
+      this._caps.shaderFloatPrecision < 10 && (this._caps.shaderFloatPrecision = 10);
+    }
+    if (this._webGLVersion > 1)
+      this._caps.blendMinMax = !0;
+    else {
+      const r = this._gl.getExtension("EXT_blend_minmax");
+      r != null && (this._caps.blendMinMax = !0, this._gl.MAX = r.MAX_EXT, this._gl.MIN = r.MIN_EXT);
+    }
+    if (!this._caps.supportSRGBBuffers) {
+      if (this._webGLVersion > 1)
+        this._caps.supportSRGBBuffers = !0, this._glSRGBExtensionValues = {
+          SRGB: WebGL2RenderingContext.SRGB,
+          SRGB8: WebGL2RenderingContext.SRGB8,
+          SRGB8_ALPHA8: WebGL2RenderingContext.SRGB8_ALPHA8
+        };
+      else {
+        const r = this._gl.getExtension("EXT_sRGB");
+        r != null && (this._caps.supportSRGBBuffers = !0, this._glSRGBExtensionValues = {
+          SRGB: r.SRGB_EXT,
+          SRGB8: r.SRGB_ALPHA_EXT,
+          SRGB8_ALPHA8: r.SRGB_ALPHA_EXT
+        });
+      }
+      if (this._creationOptions) {
+        const r = this._creationOptions.forceSRGBBufferSupportState;
+        r !== void 0 && (this._caps.supportSRGBBuffers = this._caps.supportSRGBBuffers && r);
+      }
+    }
+    this._depthCullingState.depthTest = !0, this._depthCullingState.depthFunc = this._gl.LEQUAL, this._depthCullingState.depthMask = !0, this._maxSimultaneousTextures = this._caps.maxCombinedTexturesImageUnits;
+    for (let r = 0; r < this._maxSimultaneousTextures; r++)
+      this._nextFreeTextureSlots.push(r);
+    this._glRenderer === "Mali-G72" && (this._caps.disableMorphTargetTexture = !0);
+  }
+  _initFeatures() {
+    this._features = {
+      forceBitmapOverHTMLImageElement: typeof HTMLImageElement > "u",
+      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,
+      supportIBLShadows: 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,
+      forceVertexBufferStrideAndOffsetMultiple4Bytes: !1,
+      _checkNonFloatVertexBuffersDontRecreatePipelineContext: !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";
+  }
+  /** @internal */
+  _prepareWorkingCanvas() {
+    if (this._workingCanvas)
+      return;
+    this._workingCanvas = this.createCanvas(1, 1);
+    const e = this._workingCanvas.getContext("2d");
+    e && (this._workingContext = e);
+  }
+  /**
+   * 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
+    };
+  }
+  /**Gets driver info if available */
+  extractDriverInfo() {
+    const e = this.getGlInfo();
+    return e && e.renderer ? e.renderer : "";
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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
+   * @param stencilClearValue defines the value to use to clear the stencil buffer (default is 0)
+   */
+  clear(e, t, r, s = !1, i = 0) {
+    const n = this.stencilStateComposer.useStencilGlobalOnly;
+    this.stencilStateComposer.useStencilGlobalOnly = !0, this.applyStates(), this.stencilStateComposer.useStencilGlobalOnly = n;
+    let l = 0;
+    if (t && e) {
+      let a = !0;
+      if (this._currentRenderTarget) {
+        const _ = this._currentRenderTarget.texture?.format;
+        if (_ === 8 || _ === 9 || _ === 10 || _ === 11) {
+          const u = this._currentRenderTarget.texture?.type;
+          u === 7 || u === 5 ? (T._TempClearColorUint32[0] = e.r * 255, T._TempClearColorUint32[1] = e.g * 255, T._TempClearColorUint32[2] = e.b * 255, T._TempClearColorUint32[3] = e.a * 255, this._gl.clearBufferuiv(this._gl.COLOR, 0, T._TempClearColorUint32), a = !1) : (T._TempClearColorInt32[0] = e.r * 255, T._TempClearColorInt32[1] = e.g * 255, T._TempClearColorInt32[2] = e.b * 255, T._TempClearColorInt32[3] = e.a * 255, this._gl.clearBufferiv(this._gl.COLOR, 0, T._TempClearColorInt32), a = !1);
+        }
+      }
+      a && (this._gl.clearColor(e.r, e.g, e.b, e.a !== void 0 ? e.a : 1), l |= this._gl.COLOR_BUFFER_BIT);
+    }
+    r && (this.useReverseDepthBuffer ? (this._depthCullingState.depthFunc = this._gl.GEQUAL, this._gl.clearDepth(0)) : this._gl.clearDepth(1), l |= this._gl.DEPTH_BUFFER_BIT), s && (this._gl.clearStencil(i), l |= this._gl.STENCIL_BUFFER_BIT), this._gl.clear(l);
+  }
+  /**
+   * @internal
+   */
+  _viewport(e, t, r, s) {
+    (e !== this._viewportCached.x || t !== this._viewportCached.y || r !== this._viewportCached.z || s !== this._viewportCached.w) && (this._viewportCached.x = e, this._viewportCached.y = t, this._viewportCached.z = r, this._viewportCached.w = s, this._gl.viewport(e, t, r, s));
+  }
+  /**
+   * End the current frame
+   */
+  endFrame() {
+    super.endFrame(), this._badOS && this.flushFramebuffer();
+  }
+  /**
+   * Gets the performance monitor attached to this engine
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation
+   */
+  get performanceMonitor() {
+    throw new Error("Not Supported by ThinEngine");
+  }
+  /**
+   * 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, r, s, i, n = 0, l = 0) {
+    const a = e;
+    this._currentRenderTarget && this._resolveAndGenerateMipMapsFramebuffer(this._currentRenderTarget), this._currentRenderTarget = e, this._bindUnboundFramebuffer(a._framebuffer);
+    const _ = this._gl;
+    e.isMulti || (e.is2DArray || e.is3D ? (_.framebufferTextureLayer(_.FRAMEBUFFER, _.COLOR_ATTACHMENT0, e.texture._hardwareTexture?.underlyingResource, n, l), a._currentLOD = n) : e.isCube ? _.framebufferTexture2D(_.FRAMEBUFFER, _.COLOR_ATTACHMENT0, _.TEXTURE_CUBE_MAP_POSITIVE_X + t, e.texture._hardwareTexture?.underlyingResource, n) : a._currentLOD !== n && (_.framebufferTexture2D(_.FRAMEBUFFER, _.COLOR_ATTACHMENT0, _.TEXTURE_2D, e.texture._hardwareTexture?.underlyingResource, n), a._currentLOD = n));
+    const u = e._depthStencilTexture;
+    if (u) {
+      e.is3D && (e.texture.width !== u.width || e.texture.height !== u.height || e.texture.depth !== u.depth) && I.Warn("Depth/Stencil attachment for 3D target must have same dimensions as color attachment");
+      const f = e._depthStencilTextureWithStencil ? _.DEPTH_STENCIL_ATTACHMENT : _.DEPTH_ATTACHMENT;
+      e.is2DArray || e.is3D ? _.framebufferTextureLayer(_.FRAMEBUFFER, f, u._hardwareTexture?.underlyingResource, n, l) : e.isCube ? _.framebufferTexture2D(_.FRAMEBUFFER, f, _.TEXTURE_CUBE_MAP_POSITIVE_X + t, u._hardwareTexture?.underlyingResource, n) : _.framebufferTexture2D(_.FRAMEBUFFER, f, _.TEXTURE_2D, u._hardwareTexture?.underlyingResource, n);
+    }
+    a._MSAAFramebuffer && this._bindUnboundFramebuffer(a._MSAAFramebuffer), this._cachedViewport && !i ? this.setViewport(this._cachedViewport, r, s) : (r || (r = e.width, n && (r = r / Math.pow(2, n))), s || (s = e.height, n && (s = s / Math.pow(2, n))), this._viewport(0, 0, r, s)), this.wipeCaches();
+  }
+  setStateCullFaceType(e, t) {
+    const r = this.cullBackFaces ?? e ?? !0 ? this._gl.BACK : this._gl.FRONT;
+    (this._depthCullingState.cullFace !== r || t) && (this._depthCullingState.cullFace = r);
+  }
+  /**
+   * 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, r, s = !1, i, n, l = 0) {
+    (this._depthCullingState.cull !== e || r) && (this._depthCullingState.cull = e), this.setStateCullFaceType(i, r), this.setZOffset(t), this.setZOffsetUnits(l);
+    const a = s ? this._gl.CW : this._gl.CCW;
+    (this._depthCullingState.frontFace !== a || r) && (this._depthCullingState.frontFace = a), this._stencilStateComposer.stencilMaterial = n;
+  }
+  _resolveAndGenerateMipMapsFramebuffer(e, t = !1) {
+    e.disableAutomaticMSAAResolve || (e.isMulti ? this.resolveMultiFramebuffer(e) : this.resolveFramebuffer(e)), t || (e.isMulti ? this.generateMipMapsMultiFramebuffer(e) : this.generateMipMapsFramebuffer(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) {
+    const t = this._getTextureTarget(e);
+    this._bindTextureDirectly(t, e, !0), this._gl.generateMipmap(t), this._bindTextureDirectly(t, 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, r) {
+    const s = e;
+    this._currentRenderTarget = null, this._resolveAndGenerateMipMapsFramebuffer(e, t), r && (s._MSAAFramebuffer && this._bindUnboundFramebuffer(s._framebuffer), r()), this._bindUnboundFramebuffer(null);
+  }
+  /**
+   * Generates mipmaps for the texture of the (single) render target
+   * @param texture The render target containing the texture to generate the mipmaps for
+   */
+  generateMipMapsFramebuffer(e) {
+    !e.isMulti && e.texture?.generateMipMaps && !e.isCube && this.generateMipmaps(e.texture);
+  }
+  /**
+   * Resolves the MSAA texture of the (single) render target into its non-MSAA version.
+   * Note that if "texture" is not a MSAA render target, no resolve is performed.
+   * @param texture  The render target texture containing the MSAA textures to resolve
+   */
+  resolveFramebuffer(e) {
+    const t = e, r = this._gl;
+    if (!t._MSAAFramebuffer || t.isMulti)
+      return;
+    let s = t.resolveMSAAColors ? r.COLOR_BUFFER_BIT : 0;
+    s |= t._generateDepthBuffer && t.resolveMSAADepth ? r.DEPTH_BUFFER_BIT : 0, s |= t._generateStencilBuffer && t.resolveMSAAStencil ? r.STENCIL_BUFFER_BIT : 0, r.bindFramebuffer(r.READ_FRAMEBUFFER, t._MSAAFramebuffer), r.bindFramebuffer(r.DRAW_FRAMEBUFFER, t._framebuffer), r.blitFramebuffer(0, 0, e.width, e.height, 0, 0, e.width, e.height, s, r.NEAREST);
+  }
+  /**
+   * 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 or size for the vertex buffer
+   * @param _updatable whether the buffer should be created as updatable
+   * @param _label defines the label of the buffer (for debug purpose)
+   * @returns the new WebGL static buffer
+   */
+  createVertexBuffer(e, t, r) {
+    return this._createVertexBuffer(e, this._gl.STATIC_DRAW);
+  }
+  _createVertexBuffer(e, t) {
+    const r = this._gl.createBuffer();
+    if (!r)
+      throw new Error("Unable to create vertex buffer");
+    const s = new v(r);
+    return this.bindArrayBuffer(s), typeof e != "number" ? e instanceof Array ? (this._gl.bufferData(this._gl.ARRAY_BUFFER, new Float32Array(e), t), s.capacity = e.length * 4) : (this._gl.bufferData(this._gl.ARRAY_BUFFER, e, t), s.capacity = e.byteLength) : (this._gl.bufferData(this._gl.ARRAY_BUFFER, new Uint8Array(e), t), s.capacity = e), this._resetVertexBufferBinding(), s.references = 1, s;
+  }
+  /**
+   * Creates a dynamic vertex buffer
+   * @param data the data for the dynamic vertex buffer
+   * @param _label defines the label of the buffer (for debug purpose)
+   * @returns the new WebGL dynamic buffer
+   */
+  createDynamicVertexBuffer(e, t) {
+    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
+   * @param _label defines the label of the buffer (for debug purpose)
+   * @returns a new webGL buffer
+   */
+  createIndexBuffer(e, t, r) {
+    const s = this._gl.createBuffer(), i = new v(s);
+    if (!s)
+      throw new Error("Unable to create index buffer");
+    this.bindIndexBuffer(i);
+    const n = this._normalizeIndexData(e);
+    return this._gl.bufferData(this._gl.ELEMENT_ARRAY_BUFFER, n, t ? this._gl.DYNAMIC_DRAW : this._gl.STATIC_DRAW), this._resetIndexBufferBinding(), i.references = 1, i.is32Bits = n.BYTES_PER_ELEMENT === 4, i;
+  }
+  _normalizeIndexData(e) {
+    if (e.BYTES_PER_ELEMENT === 2)
+      return e;
+    if (this._caps.uintIndices) {
+      if (e instanceof Uint32Array)
+        return e;
+      for (let r = 0; r < e.length; r++)
+        if (e[r] >= 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, r) {
+    const s = e.program, i = this._gl.getUniformBlockIndex(s, t);
+    this._gl.uniformBlockBinding(s, i, r);
+  }
+  // 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, r, s, i, n, l) {
+    const a = this._currentBufferPointers[t];
+    if (!a)
+      return;
+    let _ = !1;
+    a.active ? (a.buffer !== e && (a.buffer = e, _ = !0), a.size !== r && (a.size = r, _ = !0), a.type !== s && (a.type = s, _ = !0), a.normalized !== i && (a.normalized = i, _ = !0), a.stride !== n && (a.stride = n, _ = !0), a.offset !== l && (a.offset = l, _ = !0)) : (_ = !0, a.active = !0, a.index = t, a.size = r, a.type = s, a.normalized = i, a.stride = n, a.offset = l, a.buffer = e), (_ || this._vaoRecordInProgress) && (this.bindArrayBuffer(e), s === this._gl.UNSIGNED_INT || s === this._gl.INT ? this._gl.vertexAttribIPointer(t, r, s, n, l) : this._gl.vertexAttribPointer(t, r, s, i, n, l));
+  }
+  /**
+   * @internal
+   */
+  _bindIndexBufferWithCache(e) {
+    e != null && this._cachedIndexBuffer !== e && (this._cachedIndexBuffer = e, this.bindIndexBuffer(e), this._uintIndicesCurrentlySet = e.is32Bits);
+  }
+  _bindVertexBuffersAttributes(e, t, r) {
+    const s = t.getAttributesNames();
+    this._vaoRecordInProgress || this._unbindVertexArrayObject(), this.unbindAllAttributes();
+    for (let i = 0; i < s.length; i++) {
+      const n = t.getAttributeLocation(i);
+      if (n >= 0) {
+        const l = s[i];
+        let a = null;
+        if (r && (a = r[l]), a || (a = e[l]), !a)
+          continue;
+        this._gl.enableVertexAttribArray(n), this._vaoRecordInProgress || (this._vertexAttribArraysEnabled[n] = !0);
+        const _ = a.getBuffer();
+        _ && (this._vertexAttribPointer(_, n, a.getSize(), a.type, a.normalized, a.byteStride, a.byteOffset), a.getIsInstanced() && (this._gl.vertexAttribDivisor(n, a.getInstanceDivisor()), this._vaoRecordInProgress || (this._currentInstanceLocations.push(n), this._currentInstanceBuffers.push(_))));
+      }
+    }
+  }
+  /**
+   * 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, r, s) {
+    const i = this._gl.createVertexArray();
+    if (!i)
+      throw new Error("Unable to create VAO");
+    return this._vaoRecordInProgress = !0, this._gl.bindVertexArray(i), this._mustWipeVertexAttributes = !0, this._bindVertexBuffersAttributes(e, r, s), this.bindIndexBuffer(t), this._vaoRecordInProgress = !1, this._gl.bindVertexArray(null), i;
+  }
+  /**
+   * 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, r, s, i) {
+    if (this._cachedVertexBuffers !== e || this._cachedEffectForVertexBuffers !== i) {
+      this._cachedVertexBuffers = e, this._cachedEffectForVertexBuffers = i;
+      const n = i.getAttributesCount();
+      this._unbindVertexArrayObject(), this.unbindAllAttributes();
+      let l = 0;
+      for (let a = 0; a < n; a++)
+        if (a < r.length) {
+          const _ = i.getAttributeLocation(a);
+          _ >= 0 && (this._gl.enableVertexAttribArray(_), this._vertexAttribArraysEnabled[_] = !0, this._vertexAttribPointer(e, _, r[a], this._gl.FLOAT, !1, s, l)), l += r[a] * 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, r, s) {
+    (this._cachedVertexBuffers !== e || this._cachedEffectForVertexBuffers !== r) && (this._cachedVertexBuffers = e, this._cachedEffectForVertexBuffers = r, this._bindVertexBuffersAttributes(e, r, s)), this._bindIndexBufferWithCache(t);
+  }
+  /**
+   * Unbind all instance attributes
+   */
+  unbindInstanceAttributes() {
+    let e;
+    for (let t = 0, r = this._currentInstanceLocations.length; t < r; t++) {
+      const s = this._currentInstanceBuffers[t];
+      e != s && s.references && (e = s, this.bindArrayBuffer(s));
+      const i = this._currentInstanceLocations[t];
+      this._gl.vertexAttribDivisor(i, 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, r) {
+    if (this.bindArrayBuffer(e), t && this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, t), r[0].index !== void 0)
+      this.bindInstancesBuffer(e, r, !0);
+    else
+      for (let s = 0; s < 4; s++) {
+        const i = r[s];
+        this._vertexAttribArraysEnabled[i] || (this._gl.enableVertexAttribArray(i), this._vertexAttribArraysEnabled[i] = !0), this._vertexAttribPointer(e, i, 4, this._gl.FLOAT, !1, 64, s * 16), this._gl.vertexAttribDivisor(i, 1), this._currentInstanceLocations.push(i), 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, r = !0) {
+    this.bindArrayBuffer(e);
+    let s = 0;
+    if (r)
+      for (let i = 0; i < t.length; i++) {
+        const n = t[i];
+        s += n.attributeSize * 4;
+      }
+    for (let i = 0; i < t.length; i++) {
+      const n = t[i];
+      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, r;
+    for (; (r = this._currentInstanceLocations.indexOf(e)) !== -1; )
+      this._currentInstanceLocations.splice(r, 1), this._currentInstanceBuffers.splice(r, 1), t = !0;
+    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, r, s) {
+    this.drawElementsType(e ? 0 : 1, t, r, 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, r) {
+    this.drawArraysType(2, e, t, r);
+  }
+  /**
+   * 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, r, s) {
+    this.drawArraysType(e ? 0 : 1, t, r, 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, r, s) {
+    this.applyStates(), this._reportDrawCall();
+    const i = this._drawMode(e), n = this._uintIndicesCurrentlySet ? this._gl.UNSIGNED_INT : this._gl.UNSIGNED_SHORT, l = this._uintIndicesCurrentlySet ? 4 : 2;
+    s ? this._gl.drawElementsInstanced(i, r, n, t * l, s) : this._gl.drawElements(i, r, n, t * l);
+  }
+  /**
+   * 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, r, s) {
+    this.applyStates(), this._reportDrawCall();
+    const i = this._drawMode(e);
+    s ? this._gl.drawArraysInstanced(i, t, r, s) : this._gl.drawArrays(i, t, r);
+  }
+  _drawMode(e) {
+    switch (e) {
+      // Triangle views
+      case 0:
+        return this._gl.TRIANGLES;
+      case 2:
+        return this._gl.POINTS;
+      case 1:
+        return this._gl.LINES;
+      // Draw modes
+      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;
+    }
+  }
+  // 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, k(t), this._gl && (this._currentProgram === t.program && this._setProgram(null), this._gl.deleteProgram(t.program)));
+  }
+  /**
+   * @internal
+   */
+  _getGlobalDefines(e) {
+    return K(e, this.isNDCHalfZRange, this.useReverseDepthBuffer, this.useExactSrgbConversions);
+  }
+  /**
+   * 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)
+   * @param extraInitializationsAsync additional async code to run before preparing the effect
+   * @returns the new Effect
+   */
+  createEffect(e, t, r, s, i, n, l, a, _, u = 0, f) {
+    const c = typeof e == "string" ? e : e.vertexToken || e.vertexSource || e.vertexElement || e.vertex, d = typeof e == "string" ? e : e.fragmentToken || e.fragmentSource || e.fragmentElement || e.fragment, g = this._getGlobalDefines(), m = t.attributes !== void 0;
+    let E = i ?? t.defines ?? "";
+    g && (E += g);
+    const p = c + "+" + d + "@" + E;
+    if (this._compiledEffects[p]) {
+      const o = this._compiledEffects[p];
+      return l && o.isReady() && l(o), o._refCount++, o;
+    }
+    this._gl && L(this._gl);
+    const h = new O(e, t, m ? this : r, s, this, i, n, l, a, _, p, t.shaderLanguage ?? u, t.extraInitializationsAsync ?? f);
+    return this._compiledEffects[p] = h, h;
+  }
+  /**
+   * @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, r, s, i = null) {
+    const n = L(this._gl);
+    return n._contextWasLost = this._contextWasLost, n.validateShaderPrograms = this.validateShaderPrograms, j(e, t, r, s || this._gl, i);
+  }
+  /**
+   * 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, r, s, i, n = null) {
+    const l = L(this._gl);
+    return l._contextWasLost = this._contextWasLost, l.validateShaderPrograms = this.validateShaderPrograms, Y(e, t, r, s, i || this._gl, 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) {
+    if (this._gl) {
+      const r = L(this._gl);
+      r.parallelShaderCompile = this._caps.parallelShaderCompile;
+    }
+    const t = z(this._gl);
+    return t.engine = this, t;
+  }
+  /**
+   * Creates a new material context
+   * @returns the new context
+   */
+  createMaterialContext() {
+  }
+  /**
+   * Creates a new draw context
+   * @returns the new context
+   */
+  createDrawContext() {
+  }
+  _finalizePipelineContext(e) {
+    return Q(e, this._gl, this.validateShaderPrograms);
+  }
+  /**
+   * @internal
+   */
+  // named async but not actually an async function
+  // eslint-disable-next-line no-restricted-syntax
+  _preparePipelineContextAsync(e, t, r, s, i, n, l, a, _, u, f) {
+    const c = L(this._gl);
+    return c._contextWasLost = this._contextWasLost, c.validateShaderPrograms = this.validateShaderPrograms, c._createShaderProgramInjection = this._createShaderProgram.bind(this), c.createRawShaderProgramInjection = this.createRawShaderProgram.bind(this), c.createShaderProgramInjection = this.createShaderProgram.bind(this), c.loadFileInjection = this._loadFile.bind(this), Z(e, t, r, s, i, n, l, a, _, u, f);
+  }
+  _createShaderProgram(e, t, r, s, i = null) {
+    return $(e, t, r, s, i);
+  }
+  /**
+   * @internal
+   */
+  _isRenderingStateCompiled(e) {
+    return this._isDisposed ? !1 : q(e, this._gl, this.validateShaderPrograms);
+  }
+  /**
+   * @internal
+   */
+  _executeWhenRenderingStateIsCompiled(e, t) {
+    J(e, 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 r = new Array(), s = e;
+    for (let i = 0; i < t.length; i++)
+      r.push(this._gl.getUniformLocation(s.program, t[i]));
+    return r;
+  }
+  /**
+   * 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 r = [], s = e;
+    for (let i = 0; i < t.length; i++)
+      try {
+        r.push(this._gl.getAttribLocation(s.program, t[i]));
+      } catch {
+        r.push(-1);
+      }
+    return r;
+  }
+  /**
+   * 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 && ee(e) ? e.effect : e, !(!e || e === this._currentEffect) && (this._stencilStateComposer.stencilMaterial = void 0, 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, r) {
+    return e ? (this._gl.uniform2i(e, t, r), !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, r, s) {
+    return e ? (this._gl.uniform3i(e, t, r, 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, r, s, i) {
+    return e ? (this._gl.uniform4i(e, t, r, s, i), !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, r) {
+    return e ? (this._gl.uniform2ui(e, t, r), !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, r, s) {
+    return e ? (this._gl.uniform3ui(e, t, r, 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, r, s, i) {
+    return e ? (this._gl.uniform4ui(e, t, r, s, i), !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, r) {
+    return e ? (this._gl.uniform2f(e, t, r), !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, r, s) {
+    return e ? (this._gl.uniform3f(e, t, r, 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, r, s, i) {
+    return e ? (this._gl.uniform4f(e, t, r, s, i), !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._currentRenderTarget && this._currentRenderTarget.textures ? this._currentRenderTarget.textures.length : 1), this._colorWriteChanged) {
+      this._colorWriteChanged = !1;
+      const e = this._colorWrite;
+      this._gl.colorMask(e, e, e, e);
+    }
+  }
+  // Textures
+  /**
+   * 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._resetAlphaMode(), 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 r = this._gl;
+    let s = r.NEAREST, i = r.NEAREST, n = !1;
+    switch (e) {
+      case 11:
+        s = r.LINEAR, t ? i = r.LINEAR_MIPMAP_NEAREST : i = r.LINEAR;
+        break;
+      case 3:
+        s = r.LINEAR, n = !0, t ? i = r.LINEAR_MIPMAP_LINEAR : i = r.LINEAR;
+        break;
+      case 8:
+        n = !0, s = r.NEAREST, t ? i = r.NEAREST_MIPMAP_LINEAR : i = r.NEAREST;
+        break;
+      case 4:
+        s = r.NEAREST, t ? i = r.NEAREST_MIPMAP_NEAREST : i = r.NEAREST;
+        break;
+      case 5:
+        s = r.NEAREST, t ? i = r.LINEAR_MIPMAP_NEAREST : i = r.LINEAR;
+        break;
+      case 6:
+        n = !0, s = r.NEAREST, t ? i = r.LINEAR_MIPMAP_LINEAR : i = r.LINEAR;
+        break;
+      case 7:
+        s = r.NEAREST, i = r.LINEAR;
+        break;
+      case 1:
+        s = r.NEAREST, i = r.NEAREST;
+        break;
+      case 9:
+        s = r.LINEAR, t ? i = r.NEAREST_MIPMAP_NEAREST : i = r.NEAREST;
+        break;
+      case 10:
+        n = !0, s = r.LINEAR, t ? i = r.NEAREST_MIPMAP_LINEAR : i = r.NEAREST;
+        break;
+      case 2:
+        s = r.LINEAR, i = r.LINEAR;
+        break;
+      case 12:
+        s = r.LINEAR, i = r.NEAREST;
+        break;
+    }
+    return {
+      min: i,
+      mag: s,
+      hasMipMaps: n
+    };
+  }
+  /** @internal */
+  _createTexture() {
+    const e = this._gl.createTexture();
+    if (!e)
+      throw new Error("Unable to create texture");
+    return e;
+  }
+  /** @internal */
+  _createHardwareTexture() {
+    return new _e(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, r = !0, s = 0) {
+    let i, n = !1, l = 0, a = 3, _ = 5, u = !1, f = 1, c, d = !1, g = 0, m = !1;
+    t !== void 0 && typeof t == "object" ? (i = !!t.generateMipMaps, n = !!t.createMipMaps, l = t.type === void 0 ? 0 : t.type, a = t.samplingMode === void 0 ? 3 : t.samplingMode, _ = t.format === void 0 ? 5 : t.format, u = t.useSRGBBuffer === void 0 ? !1 : t.useSRGBBuffer, f = t.samples ?? 1, c = t.label, d = !!t.createMSAATexture, g = t.comparisonFunction || 0, m = !!t.isCube) : i = !!t, u && (u = this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU)), (l === 1 && !this._caps.textureFloatLinearFiltering || l === 2 && !this._caps.textureHalfFloatLinearFiltering) && (a = 1), l === 1 && !this._caps.textureFloat && (l = 0, I.Warn("Float textures are not supported. Type forced to TEXTURETYPE_UNSIGNED_BYTE"));
+    const E = H(_), p = V(_), h = this._gl, o = new y(this, s), S = e.width || e, C = e.height || e, b = e.depth || 0, G = e.layers || 0, x = this._getSamplingParameters(a, (i || n) && !E), A = G !== 0 ? h.TEXTURE_2D_ARRAY : b !== 0 ? h.TEXTURE_3D : m ? h.TEXTURE_CUBE_MAP : h.TEXTURE_2D, B = E ? this._getInternalFormatFromDepthTextureFormat(_, !0, p) : this._getRGBABufferInternalSizedFormat(l, _, u), M = E ? p ? h.DEPTH_STENCIL : h.DEPTH_COMPONENT : this._getInternalFormat(_), F = E ? this._getWebGLTextureTypeFromDepthTextureFormat(_) : this._getWebGLTextureType(l);
+    if (this._bindTextureDirectly(A, o), G !== 0)
+      o.is2DArray = !0, h.texImage3D(A, 0, B, S, C, G, 0, M, F, null);
+    else if (b !== 0)
+      o.is3D = !0, h.texImage3D(A, 0, B, S, C, b, 0, M, F, null);
+    else if (m) {
+      o.isCube = !0;
+      for (let P = 0; P < 6; P++)
+        h.texImage2D(h.TEXTURE_CUBE_MAP_POSITIVE_X + P, 0, B, S, C, 0, M, F, null);
+    } else
+      h.texImage2D(A, 0, B, S, C, 0, M, F, null);
+    if (h.texParameteri(A, h.TEXTURE_MAG_FILTER, x.mag), h.texParameteri(A, h.TEXTURE_MIN_FILTER, x.min), h.texParameteri(A, h.TEXTURE_WRAP_S, h.CLAMP_TO_EDGE), h.texParameteri(A, h.TEXTURE_WRAP_T, h.CLAMP_TO_EDGE), E && this.webGLVersion > 1 && (g === 0 ? (h.texParameteri(A, h.TEXTURE_COMPARE_FUNC, 515), h.texParameteri(A, h.TEXTURE_COMPARE_MODE, h.NONE)) : (h.texParameteri(A, h.TEXTURE_COMPARE_FUNC, g), h.texParameteri(A, h.TEXTURE_COMPARE_MODE, h.COMPARE_REF_TO_TEXTURE))), (i || n) && this._gl.generateMipmap(A), this._bindTextureDirectly(A, null), o._useSRGBBuffer = u, o.baseWidth = S, o.baseHeight = C, o.width = S, o.height = C, o.depth = G || b, o.isReady = !0, o.samples = f, o.generateMipMaps = i, o.samplingMode = a, o.type = l, o.format = _, o.label = c, o.comparisonFunction = g, this._internalTexturesCache.push(o), d) {
+      let P;
+      if (H(o.format) ? P = this._setupFramebufferDepthAttachments(V(o.format), o.format !== 19, o.width, o.height, f, o.format, !0) : P = this._createRenderBuffer(
+        o.width,
+        o.height,
+        f,
+        -1,
+        this._getRGBABufferInternalSizedFormat(o.type, o.format, o._useSRGBBuffer),
+        -1
+        /* attachment */
+      ), !P)
+        throw new Error("Unable to create render buffer");
+      o._autoMSAAManagement = !0;
+      let D = o._hardwareTexture;
+      D || (D = o._hardwareTexture = this._createHardwareTexture()), D.addMSAARenderBuffer(P);
+    }
+    return o;
+  }
+  /**
+   * @internal
+   */
+  _getUseSRGBBuffer(e, t) {
+    return e && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || t);
+  }
+  /**
+   * 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, r, s, i = 3, n = null, l = null, a = null, _ = null, u = null, f = null, c, d, g, m) {
+    return this._createTextureBase(e, t, r, s, i, n, l, (...E) => this._prepareWebGLTexture(...E, u), (E, p, h, o, S, C) => {
+      const b = this._gl, G = h.width === E && h.height === p;
+      S._creationFlags = g ?? 0;
+      const x = this._getTexImageParametersForCreateTexture(S.format, S._useSRGBBuffer);
+      if (G)
+        return b.texImage2D(b.TEXTURE_2D, 0, x.internalFormat, x.format, x.type, h), !1;
+      const A = this._caps.maxTextureSize;
+      if (h.width > A || h.height > A || !this._supportsHardwareTextureRescaling)
+        return this._prepareWorkingCanvas(), !this._workingCanvas || !this._workingContext || (this._workingCanvas.width = E, this._workingCanvas.height = p, this._workingContext.drawImage(h, 0, 0, h.width, h.height, 0, 0, E, p), b.texImage2D(b.TEXTURE_2D, 0, x.internalFormat, x.format, x.type, this._workingCanvas), S.width = E, S.height = p), !1;
+      {
+        const B = new y(
+          this,
+          2
+          /* InternalTextureSource.Temp */
+        );
+        this._bindTextureDirectly(b.TEXTURE_2D, B, !0), b.texImage2D(b.TEXTURE_2D, 0, x.internalFormat, x.format, x.type, h), this._rescaleTexture(B, S, s, x.format, () => {
+          this._releaseTexture(B), this._bindTextureDirectly(b.TEXTURE_2D, S, !0), C();
+        });
+      }
+      return !0;
+    }, a, _, u, f, c, d, m);
+  }
+  /**
+   * Calls to the GL texImage2D and texImage3D functions require three arguments describing the pixel format of the texture.
+   * createTexture derives these from the babylonFormat and useSRGBBuffer arguments and also the file extension of the URL it's working with.
+   * This function encapsulates that derivation for easy unit testing.
+   * @param babylonFormat Babylon's format enum, as specified in ITextureCreationOptions.
+   * @param fileExtension The file extension including the dot, e.g. .jpg.
+   * @param useSRGBBuffer Use SRGB not linear.
+   * @returns The options to pass to texImage2D or texImage3D calls.
+   * @internal
+   */
+  _getTexImageParametersForCreateTexture(e, t) {
+    let r, s;
+    return this.webGLVersion === 1 ? (r = this._getInternalFormat(e, t), s = r) : (r = this._getInternalFormat(e, !1), s = this._getRGBABufferInternalSizedFormat(0, e, t)), {
+      internalFormat: s,
+      format: r,
+      type: this._gl.UNSIGNED_BYTE
+    };
+  }
+  /**
+   * @internal
+   */
+  _rescaleTexture(e, t, r, s, i) {
+  }
+  /**
+   * @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);
+  }
+  /** @internal */
+  _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, r = !1) {
+    const s = this._getTextureTarget(t), i = this._getSamplingParameters(e, t.useMipMaps || r);
+    this._setTextureParameterInteger(s, this._gl.TEXTURE_MAG_FILTER, i.mag, t), this._setTextureParameterInteger(s, this._gl.TEXTURE_MIN_FILTER, i.min), r && i.hasMipMaps && (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, r, 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, r = null, s = null) {
+    const i = this._getTextureTarget(e);
+    t !== null && (this._setTextureParameterInteger(i, this._gl.TEXTURE_WRAP_S, this._getTextureWrapMode(t), e), e._cachedWrapU = t), r !== null && (this._setTextureParameterInteger(i, this._gl.TEXTURE_WRAP_T, this._getTextureWrapMode(r), e), e._cachedWrapV = r), (e.is2DArray || e.is3D) && s !== null && (this._setTextureParameterInteger(i, this._gl.TEXTURE_WRAP_R, this._getTextureWrapMode(s), e), e._cachedWrapR = s), this._bindTextureDirectly(i, null);
+  }
+  /**
+   * @internal
+   */
+  _uploadCompressedDataToTextureDirectly(e, t, r, s, i, n = 0, l = 0) {
+    const a = this._gl;
+    let _ = a.TEXTURE_2D;
+    if (e.isCube && (_ = a.TEXTURE_CUBE_MAP_POSITIVE_X + n), e._useSRGBBuffer)
+      switch (t) {
+        case 37492:
+        case 36196:
+          this._caps.etc2 ? t = a.COMPRESSED_SRGB8_ETC2 : e._useSRGBBuffer = !1;
+          break;
+        case 37496:
+          this._caps.etc2 ? t = a.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : e._useSRGBBuffer = !1;
+          break;
+        case 36492:
+          t = a.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT;
+          break;
+        case 37808:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
+          break;
+        case 37809:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR;
+          break;
+        case 37810:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR;
+          break;
+        case 37811:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR;
+          break;
+        case 37812:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR;
+          break;
+        case 37813:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR;
+          break;
+        case 37814:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR;
+          break;
+        case 37815:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR;
+          break;
+        case 37816:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR;
+          break;
+        case 37817:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR;
+          break;
+        case 37818:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR;
+          break;
+        case 37819:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR;
+          break;
+        case 37820:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR;
+          break;
+        case 37821:
+          t = a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR;
+          break;
+        case 33776:
+          this._caps.s3tc_srgb ? t = a.COMPRESSED_SRGB_S3TC_DXT1_EXT : e._useSRGBBuffer = !1;
+          break;
+        case 33777:
+          this._caps.s3tc_srgb ? t = a.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT : e._useSRGBBuffer = !1;
+          break;
+        case 33779:
+          this._caps.s3tc_srgb ? t = a.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : e._useSRGBBuffer = !1;
+          break;
+        default:
+          e._useSRGBBuffer = !1;
+          break;
+      }
+    if (e.generateMipMaps) {
+      const u = e._hardwareTexture;
+      u.memoryAllocated || (a.texStorage2D(e.isCube ? a.TEXTURE_CUBE_MAP : a.TEXTURE_2D, Math.floor(Math.log2(Math.max(r, s))) + 1, t, e.width, e.height), u.memoryAllocated = !0), this._gl.compressedTexSubImage2D(_, l, 0, 0, r, s, t, i);
+    } else
+      this._gl.compressedTexImage2D(_, l, t, r, s, 0, i);
+  }
+  /**
+   * @internal
+   */
+  _uploadDataToTextureDirectly(e, t, r = 0, s = 0, i, n = !1) {
+    const l = this._gl, a = this._getWebGLTextureType(e.type), _ = this._getInternalFormat(e.format), u = i === void 0 ? this._getRGBABufferInternalSizedFormat(e.type, e.format, e._useSRGBBuffer) : this._getInternalFormat(i, e._useSRGBBuffer);
+    this._unpackFlipY(e.invertY);
+    let f = l.TEXTURE_2D;
+    e.isCube && (f = l.TEXTURE_CUBE_MAP_POSITIVE_X + r);
+    const c = Math.round(Math.log(e.width) * Math.LOG2E), d = Math.round(Math.log(e.height) * Math.LOG2E), g = n ? e.width : Math.pow(2, Math.max(c - s, 0)), m = n ? e.height : Math.pow(2, Math.max(d - s, 0));
+    l.texImage2D(f, s, u, g, m, 0, _, a, 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, r, s, i, n, l = 0, a = 0, _ = !1) {
+    const u = this._gl, f = this._getWebGLTextureType(e.type), c = this._getInternalFormat(e.format);
+    this._unpackFlipY(e.invertY);
+    let d = u.TEXTURE_2D, g = u.TEXTURE_2D;
+    e.isCube && (g = u.TEXTURE_CUBE_MAP_POSITIVE_X + l, d = u.TEXTURE_CUBE_MAP), this._bindTextureDirectly(d, e, !0), u.texSubImage2D(g, a, r, s, i, n, c, f, t), _ && this._gl.generateMipmap(g), this._bindTextureDirectly(d, null);
+  }
+  /**
+   * @internal
+   */
+  _uploadArrayBufferViewToTexture(e, t, r = 0, s = 0) {
+    const i = this._gl, n = e.isCube ? i.TEXTURE_CUBE_MAP : i.TEXTURE_2D;
+    this._bindTextureDirectly(n, e, !0), this._uploadDataToTextureDirectly(e, t, r, s), this._bindTextureDirectly(n, null, !0);
+  }
+  _prepareWebGLTextureContinuation(e, t, r, s, i) {
+    const n = this._gl;
+    if (!n)
+      return;
+    const l = this._getSamplingParameters(i, !r);
+    n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, l.mag), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, l.min), !r && !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, r, s, i, n, l, a, _, u) {
+    const f = this.getCaps().maxTextureSize, c = Math.min(f, this.needPOTTextures ? N(s.width, f) : s.width), d = Math.min(f, this.needPOTTextures ? N(s.height, f) : s.height), g = this._gl;
+    if (g) {
+      if (!e._hardwareTexture) {
+        r && r.removePendingData(e);
+        return;
+      }
+      this._bindTextureDirectly(g.TEXTURE_2D, e, !0), this._unpackFlipY(i === void 0 ? !0 : !!i), e.baseWidth = s.width, e.baseHeight = s.height, e.width = c, e.height = d, e.isReady = !0, e.type = e.type !== -1 ? e.type : 0, e.format = e.format !== -1 ? e.format : u ?? (t === ".jpg" && !e._useSRGBBuffer ? 4 : 5), !a(c, d, s, t, e, () => {
+        this._prepareWebGLTextureContinuation(e, r, n, l, _);
+      }) && this._prepareWebGLTextureContinuation(e, r, n, l, _);
+    }
+  }
+  _getInternalFormatFromDepthTextureFormat(e, t, r) {
+    const s = this._gl;
+    if (!t)
+      return s.STENCIL_INDEX8;
+    let n = r ? s.DEPTH_STENCIL : s.DEPTH_COMPONENT;
+    return this.webGLVersion > 1 ? e === 15 ? n = s.DEPTH_COMPONENT16 : e === 16 ? n = s.DEPTH_COMPONENT24 : e === 17 || e === 13 ? n = r ? s.DEPTH24_STENCIL8 : s.DEPTH_COMPONENT24 : e === 14 ? n = s.DEPTH_COMPONENT32F : e === 18 && (n = r ? s.DEPTH32F_STENCIL8 : s.DEPTH_COMPONENT32F) : n = s.DEPTH_COMPONENT16, n;
+  }
+  _getWebGLTextureTypeFromDepthTextureFormat(e) {
+    const t = this._gl;
+    let r = t.UNSIGNED_INT;
+    return e === 15 ? r = t.UNSIGNED_SHORT : e === 17 || e === 13 ? r = t.UNSIGNED_INT_24_8 : e === 14 ? r = t.FLOAT : e === 18 ? r = t.FLOAT_32_UNSIGNED_INT_24_8_REV : e === 19 && (r = t.UNSIGNED_BYTE), r;
+  }
+  /**
+   * @internal
+   */
+  _setupFramebufferDepthAttachments(e, t, r, s, i = 1, n, l = !1) {
+    const a = this._gl;
+    n = n ?? (e ? 13 : 14);
+    const _ = this._getInternalFormatFromDepthTextureFormat(n, t, e);
+    return e && t ? this._createRenderBuffer(r, s, i, a.DEPTH_STENCIL, _, l ? -1 : a.DEPTH_STENCIL_ATTACHMENT) : t ? this._createRenderBuffer(r, s, i, _, _, l ? -1 : a.DEPTH_ATTACHMENT) : e ? this._createRenderBuffer(r, s, i, _, _, l ? -1 : a.STENCIL_ATTACHMENT) : null;
+  }
+  /**
+   * @internal
+   */
+  _createRenderBuffer(e, t, r, s, i, n, l = !0) {
+    const _ = this._gl.createRenderbuffer();
+    return this._updateRenderBuffer(_, e, t, r, s, i, n, l);
+  }
+  _updateRenderBuffer(e, t, r, s, i, n, l, a = !0) {
+    const _ = this._gl;
+    return _.bindRenderbuffer(_.RENDERBUFFER, e), s > 1 && _.renderbufferStorageMultisample ? _.renderbufferStorageMultisample(_.RENDERBUFFER, s, n, t, r) : _.renderbufferStorage(_.RENDERBUFFER, i, t, r), l !== -1 && _.framebufferRenderbuffer(_.FRAMEBUFFER, l, _.RENDERBUFFER, e), a && _.bindRenderbuffer(_.RENDERBUFFER, null), e;
+  }
+  /**
+   * @internal
+   */
+  _releaseTexture(e) {
+    this._deleteTexture(e._hardwareTexture), this.unbindAllTextures();
+    const t = this._internalTexturesCache.indexOf(e);
+    t !== -1 && this._internalTexturesCache.splice(t, 1), e._lodTextureHigh && e._lodTextureHigh.dispose(), e._lodTextureMid && e._lodTextureMid.dispose(), e._lodTextureLow && e._lodTextureLow.dispose(), e._irradianceTexture && e._irradianceTexture.dispose();
+  }
+  _deleteTexture(e) {
+    e?.release();
+  }
+  _setProgram(e) {
+    this._currentProgram !== e && (te(e, this._gl), 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 r = e.getSamplers();
+    for (let s = 0; s < r.length; s++) {
+      const i = e.getUniform(r[s]);
+      i && (this._boundUniforms[s] = i);
+    }
+    this._currentEffect = null;
+  }
+  _activateCurrentTexture() {
+    this._currentTextureChannel !== this._activeChannel && (this._gl.activeTexture(this._gl.TEXTURE0 + this._activeChannel), this._currentTextureChannel = this._activeChannel);
+  }
+  /**
+   * @internal
+   */
+  _bindTextureDirectly(e, t, r = !1, s = !1) {
+    let i = !1;
+    const n = t && t._associatedChannel > -1;
+    if (r && n && (this._activeChannel = t._associatedChannel), this._boundTexturesCache[this._activeChannel] !== t || s) {
+      if (this._activateCurrentTexture(), t && t.isMultiview)
+        throw I.Error(["_bindTextureDirectly called with a multiview texture!", e, t]), "_bindTextureDirectly called with a multiview texture!";
+      this._gl.bindTexture(e, t?._hardwareTexture?.underlyingResource ?? null), this._boundTexturesCache[this._activeChannel] = t, t && (t._associatedChannel = this._activeChannel);
+    } else r && (i = !0, this._activateCurrentTexture());
+    return n && !r && this._bindSamplerUniformToChannel(t._associatedChannel, this._activeChannel), i;
+  }
+  /**
+   * @internal
+   */
+  _bindTexture(e, t, r) {
+    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, r, s) {
+    e !== void 0 && (t && (this._boundUniforms[e] = t), this._setTexture(e, r));
+  }
+  _bindSamplerUniformToChannel(e, t) {
+    const r = this._boundUniforms[e];
+    !r || r._currentState === t || (this._gl.uniform1i(r, t), r._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, r = !1, s = !1, i = "") {
+    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;
+      const _ = t.getInternalTexture();
+      _ && (_._associatedChannel = 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, !r && n && (n._associatedChannel = e);
+    let l = !0;
+    this._boundTexturesCache[e] === n && (r || this._bindSamplerUniformToChannel(n._associatedChannel, e), l = !1), this._activeChannel = e;
+    const a = this._getTextureTarget(n);
+    if (l && this._bindTextureDirectly(a, n, r), n && !n.isMultiview) {
+      if (n.isCube && n._cachedCoordinatesMode !== t.coordinatesMode) {
+        n._cachedCoordinatesMode = t.coordinatesMode;
+        const _ = t.coordinatesMode !== 3 && t.coordinatesMode !== 5 ? 1 : 0;
+        t.wrapU = _, t.wrapV = _;
+      }
+      n._cachedWrapU !== t.wrapU && (n._cachedWrapU = t.wrapU, this._setTextureParameterInteger(a, this._gl.TEXTURE_WRAP_S, this._getTextureWrapMode(t.wrapU), n)), n._cachedWrapV !== t.wrapV && (n._cachedWrapV = t.wrapV, this._setTextureParameterInteger(a, this._gl.TEXTURE_WRAP_T, this._getTextureWrapMode(t.wrapV), n)), n.is3D && n._cachedWrapR !== t.wrapR && (n._cachedWrapR = t.wrapR, this._setTextureParameterInteger(a, this._gl.TEXTURE_WRAP_R, this._getTextureWrapMode(t.wrapR), n)), this._setAnisotropicLevel(a, 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, r, s) {
+    if (!(e === void 0 || !t)) {
+      (!this._textureUnits || this._textureUnits.length !== r.length) && (this._textureUnits = new Int32Array(r.length));
+      for (let i = 0; i < r.length; i++) {
+        const n = r[i].getInternalTexture();
+        n ? (this._textureUnits[i] = e + i, n._associatedChannel = e + i) : this._textureUnits[i] = -1;
+      }
+      this._gl.uniform1iv(t, this._textureUnits);
+      for (let i = 0; i < r.length; i++)
+        this._setTexture(this._textureUnits[i], r[i], !0);
+    }
+  }
+  /**
+   * @internal
+   */
+  _setAnisotropicLevel(e, t, r) {
+    const s = this._caps.textureAnisotropicFilterExtension;
+    t.samplingMode !== 11 && t.samplingMode !== 3 && t.samplingMode !== 2 && (r = 1), s && t._cachedAnisotropicFilteringLevel !== r && (this._setTextureParameterFloat(e, s.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(r, this._caps.maxAnisotropy), t), t._cachedAnisotropicFilteringLevel = r);
+  }
+  _setTextureParameterFloat(e, t, r, s) {
+    this._bindTextureDirectly(e, s, !0, !0), this._gl.texParameterf(e, t, r);
+  }
+  _setTextureParameterInteger(e, t, r, s) {
+    s && this._bindTextureDirectly(e, s, !0, !0), this._gl.texParameteri(e, t, r);
+  }
+  /**
+   * 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() {
+    this._compiledEffects = {}, this.onReleaseEffectsObservable.notifyObservers(this);
+  }
+  /**
+   * Dispose and release all associated resources
+   */
+  dispose() {
+    re() && this._renderingCanvas && (this._renderingCanvas.removeEventListener("webglcontextlost", this._onContextLost), this._onContextRestored && this._renderingCanvas.removeEventListener("webglcontextrestored", this._onContextRestored)), super.dispose(), this._dummyFramebuffer && this._gl.deleteFramebuffer(this._dummyFramebuffer), this.unbindAllAttributes(), this._boundUniforms = {}, this._workingCanvas = null, this._workingContext = null, this._currentBufferPointers.length = 0, this._currentProgram = null, this._creationOptions.loseContextOnDispose && this._gl.getExtension("WEBGL_lose_context")?.loseContext(), U(this._gl);
+  }
+  /**
+   * 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 r = !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 i = t.createFramebuffer();
+    t.bindFramebuffer(t.FRAMEBUFFER, i), t.framebufferTexture2D(t.FRAMEBUFFER, t.COLOR_ATTACHMENT0, t.TEXTURE_2D, s, 0);
+    const n = t.checkFramebufferStatus(t.FRAMEBUFFER);
+    if (r = r && n === t.FRAMEBUFFER_COMPLETE, r = r && t.getError() === t.NO_ERROR, r && (t.clear(t.COLOR_BUFFER_BIT), r = r && t.getError() === t.NO_ERROR), r) {
+      t.bindFramebuffer(t.FRAMEBUFFER, null);
+      const l = t.RGBA, a = t.UNSIGNED_BYTE, _ = new Uint8Array(4);
+      t.readPixels(0, 0, 1, 1, l, a, _), r = r && t.getError() === t.NO_ERROR;
+    }
+    for (t.deleteTexture(s), t.deleteFramebuffer(i), t.bindFramebuffer(t.FRAMEBUFFER, null); !r && t.getError() !== t.NO_ERROR; )
+      ;
+    return r;
+  }
+  /**
+   * @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 r = t ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA;
+    switch (e) {
+      case 0:
+        r = this._gl.ALPHA;
+        break;
+      case 1:
+        r = this._gl.LUMINANCE;
+        break;
+      case 2:
+        r = this._gl.LUMINANCE_ALPHA;
+        break;
+      case 6:
+      case 33322:
+      case 36760:
+        r = this._gl.RED;
+        break;
+      case 7:
+      case 33324:
+      case 36761:
+        r = this._gl.RG;
+        break;
+      case 4:
+      case 32852:
+      case 36762:
+        r = t ? this._glSRGBExtensionValues.SRGB : this._gl.RGB;
+        break;
+      case 5:
+      case 32859:
+      case 36763:
+        r = t ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA;
+        break;
+    }
+    if (this._webGLVersion > 1)
+      switch (e) {
+        case 8:
+          r = this._gl.RED_INTEGER;
+          break;
+        case 9:
+          r = this._gl.RG_INTEGER;
+          break;
+        case 10:
+          r = this._gl.RGB_INTEGER;
+          break;
+        case 11:
+          r = this._gl.RGBA_INTEGER;
+          break;
+      }
+    return r;
+  }
+  /**
+   * @internal
+   */
+  _getRGBABufferInternalSizedFormat(e, t, r = !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 r ? this._glSRGBExtensionValues.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 r ? this._glSRGBExtensionValues.SRGB8 : this._gl.RGB8;
+          // By default. Other possibilities are RGB565, SRGB8.
+          case 5:
+            return r ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA8;
+          // By default. Other possibilities are RGB5_A1, RGBA4, SRGB8_ALPHA8.
+          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 36760:
+            return this._gl.R16_SNORM_EXT;
+          case 36761:
+            return this._gl.RG16_SNORM_EXT;
+          case 36762:
+            return this._gl.RGB16_SNORM_EXT;
+          case 36763:
+            return this._gl.RGBA16_SNORM_EXT;
+          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 33322:
+            return this._gl.R16_EXT;
+          case 33324:
+            return this._gl.RG16_EXT;
+          case 32852:
+            return this._gl.RGB16_EXT;
+          case 32859:
+            return this._gl.RGBA16_EXT;
+          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;
+          // By default. Other possibility is R16F.
+          case 7:
+            return this._gl.RG32F;
+          // By default. Other possibility is RG16F.
+          case 4:
+            return this._gl.RGB32F;
+          // By default. Other possibilities are RGB16F, R11F_G11F_B10F, RGB9_E5.
+          case 5:
+            return this._gl.RGBA32F;
+          // By default. Other possibility is RGBA16F.
+          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;
+          // By default. Other possibilities are R11F_G11F_B10F, RGB9_E5.
+          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;
+          // By default. Other possibility is RGB5_A1.
+          case 11:
+            return this._gl.RGB10_A2UI;
+          default:
+            return this._gl.RGB10_A2;
+        }
+    }
+    return r ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA8;
+  }
+  /**
+   * 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
+   * @param data defines the data to fill with the read pixels (if not provided, a new one will be created)
+   * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors
+   */
+  // Async function, not named Async and not marked as async to avoid breaking changes
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
+  readPixels(e, t, r, s, i = !0, n = !0, l = null) {
+    const a = i ? 4 : 3, _ = i ? this._gl.RGBA : this._gl.RGB, u = r * s * a;
+    if (!l)
+      l = new Uint8Array(u);
+    else if (l.length < u)
+      return I.Error(`Data buffer is too small to store the read pixels (${l.length} should be more than ${u})`), Promise.resolve(l);
+    return n && this.flushFramebuffer(), this._gl.readPixels(e, t, r, s, _, this._gl.UNSIGNED_BYTE, l), Promise.resolve(l);
+  }
+  /**
+   * Gets a Promise<boolean> indicating if the engine can be instantiated (ie. if a webGL context can be found)
+   */
+  // eslint-disable-next-line no-restricted-syntax
+  static get IsSupportedAsync() {
+    return Promise.resolve(this.isSupported());
+  }
+  /**
+   * Gets a boolean indicating if the engine can be instantiated (ie. if a webGL context can be found)
+   */
+  static get IsSupported() {
+    return this.isSupported();
+  }
+  /**
+   * Gets a boolean indicating if the engine can be instantiated (ie. if a webGL context can be found)
+   * @returns true if the engine can be created
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static isSupported() {
+    if (this._HasMajorPerformanceCaveat !== null)
+      return !this._HasMajorPerformanceCaveat;
+    if (this._IsSupported === null)
+      try {
+        const e = w._CreateCanvas(1, 1), t = e.getContext("webgl") || e.getContext("experimental-webgl");
+        this._IsSupported = t != null && !!globalThis.WebGLRenderingContext;
+      } catch {
+        this._IsSupported = !1;
+      }
+    return this._IsSupported;
+  }
+  /**
+   * Gets a boolean indicating if the engine can be instantiated on a performant device (ie. if a webGL context can be found and it does not use a slow implementation)
+   */
+  static get HasMajorPerformanceCaveat() {
+    if (this._HasMajorPerformanceCaveat === null)
+      try {
+        const e = w._CreateCanvas(1, 1), t = e.getContext("webgl", { failIfMajorPerformanceCaveat: !0 }) || e.getContext("experimental-webgl", { failIfMajorPerformanceCaveat: !0 });
+        this._HasMajorPerformanceCaveat = !t;
+      } catch {
+        this._HasMajorPerformanceCaveat = !1;
+      }
+    return this._HasMajorPerformanceCaveat;
+  }
+}
+T._TempClearColorUint32 = new Uint32Array(4);
+T._TempClearColorInt32 = new Int32Array(4);
+T.ExceptionList = [
+  { key: "Chrome/63.0", capture: "63\\.0\\.3239\\.(\\d+)", captureConstraint: 108, targets: ["uniformBuffer"] },
+  { key: "Firefox/58", capture: null, captureConstraint: null, targets: ["uniformBuffer"] },
+  { key: "Firefox/59", capture: null, captureConstraint: null, targets: ["uniformBuffer"] },
+  { key: "Chrome/72.+?Mobile", capture: null, captureConstraint: null, targets: ["vao"] },
+  { key: "Chrome/73.+?Mobile", capture: null, captureConstraint: null, targets: ["vao"] },
+  { key: "Chrome/74.+?Mobile", capture: null, captureConstraint: null, targets: ["vao"] },
+  { key: "Mac OS.+Chrome/71", capture: null, captureConstraint: null, targets: ["vao"] },
+  { key: "Mac OS.+Chrome/72", capture: null, captureConstraint: null, targets: ["vao"] },
+  { key: "Mac OS.+Chrome", capture: null, captureConstraint: null, targets: ["uniformBuffer"] },
+  { key: "Chrome/12\\d\\..+?Mobile", capture: null, captureConstraint: null, targets: ["uniformBuffer"] },
+  // desktop osx safari 15.4
+  { key: ".*AppleWebKit.*(15.4).*Safari", capture: null, captureConstraint: null, targets: ["antialias", "maxMSAASamples"] },
+  // mobile browsers using safari 15.4 on ios
+  { key: ".*(15.4).*AppleWebKit.*Safari", capture: null, captureConstraint: null, targets: ["antialias", "maxMSAASamples"] }
+];
+T._ConcatenateShader = se;
+T._IsSupported = null;
+T._HasMajorPerformanceCaveat = null;
+export {
+  T as ThinEngine
+};