holostaff-widget 3.0.2 → 3.0.3

package/dist/WebGLRenderer-BtNMOOvs.js

@@ -0,0 +1,2237 @@
+import { D as x, E as f, B, w as p, g as he, T as R, m as ue, k as de, R as L, j as A, i as C, d as le, M as X, A as fe, e as g, o as Ee, p as me, q as be } from "./index-BpOQ7Z5z.js";
+import { G as D, e as pe, S as T, R as Re, h as V, i as xe, j as W, k as Te, l as Se, b as ge, d as Be } from "./RenderTargetSystem-Bl4mRBf3.js";
+import { e as Ae, G as Ce, b as k, c as Ne } from "./GpuStencilModesToPixi-Cc8Nerk4.js";
+import { S as U, G as Ge, a as y, R as Ie } from "./Filter-GqToX76B.js";
+function De() {
+  const { userAgent: r } = x.get().getNavigator();
+  return /^((?!chrome|android).)*safari/i.test(r);
+}
+class K {
+  constructor() {
+    this._tempState = U.for2d(), this._didUploadHash = {};
+  }
+  init(e) {
+    e.renderer.runners.contextChange.add(this);
+  }
+  contextChange() {
+    this._didUploadHash = {};
+  }
+  start(e, t, s) {
+    const n = e.renderer, i = this._didUploadHash[s.uid];
+    n.shader.bind(s, i), i || (this._didUploadHash[s.uid] = !0), n.shader.updateUniformGroup(n.globalUniforms.uniformGroup), n.geometry.bind(t, s.glProgram);
+  }
+  execute(e, t) {
+    const s = e.renderer;
+    this._tempState.blendMode = t.blendMode, s.state.set(this._tempState);
+    const n = t.textures.textures;
+    for (let i = 0; i < t.textures.count; i++)
+      s.texture.bind(n[i], i);
+    s.geometry.draw(t.topology, t.size, t.start);
+  }
+}
+K.extension = {
+  type: [
+    f.WebGLPipesAdaptor
+  ],
+  name: "batch"
+};
+var S = /* @__PURE__ */ ((r) => (r[r.ELEMENT_ARRAY_BUFFER = 34963] = "ELEMENT_ARRAY_BUFFER", r[r.ARRAY_BUFFER = 34962] = "ARRAY_BUFFER", r[r.UNIFORM_BUFFER = 35345] = "UNIFORM_BUFFER", r))(S || {});
+class Ue {
+  constructor(e, t) {
+    this._lastBindBaseLocation = -1, this._lastBindCallId = -1, this.buffer = e || null, this.updateID = -1, this.byteLength = -1, this.type = t;
+  }
+  destroy() {
+    this.buffer = null, this.updateID = -1, this.byteLength = -1, this.type = -1, this._lastBindBaseLocation = -1, this._lastBindCallId = -1;
+  }
+}
+class j {
+  /**
+   * @param {Renderer} renderer - The renderer this System works for.
+   */
+  constructor(e) {
+    this._boundBufferBases = /* @__PURE__ */ Object.create(null), this._minBaseLocation = 0, this._nextBindBaseIndex = this._minBaseLocation, this._bindCallId = 0, this._renderer = e, this._managedBuffers = new D({
+      renderer: e,
+      type: "resource",
+      onUnload: this.onBufferUnload.bind(this),
+      name: "glBuffer"
+    });
+  }
+  /** @ignore */
+  destroy() {
+    this._managedBuffers.destroy(), this._renderer = null, this._gl = null, this._boundBufferBases = {};
+  }
+  /** Sets up the renderer context and necessary buffers. */
+  contextChange() {
+    this._gl = this._renderer.gl, this.destroyAll(!0), this._maxBindings = this._renderer.limits.maxUniformBindings;
+  }
+  getGlBuffer(e) {
+    return e._gcLastUsed = this._renderer.gc.now, e._gpuData[this._renderer.uid] || this.createGLBuffer(e);
+  }
+  /**
+   * This binds specified buffer. On first run, it will create the webGL buffers for the context too
+   * @param buffer - the buffer to bind to the renderer
+   */
+  bind(e) {
+    const { _gl: t } = this, s = this.getGlBuffer(e);
+    t.bindBuffer(s.type, s.buffer);
+  }
+  /**
+   * Binds an uniform buffer to at the given index.
+   *
+   * A cache is used so a buffer will not be bound again if already bound.
+   * @param glBuffer - the buffer to bind
+   * @param index - the base index to bind it to.
+   */
+  bindBufferBase(e, t) {
+    const { _gl: s } = this;
+    this._boundBufferBases[t] !== e && (this._boundBufferBases[t] = e, e._lastBindBaseLocation = t, s.bindBufferBase(s.UNIFORM_BUFFER, t, e.buffer));
+  }
+  nextBindBase(e) {
+    this._bindCallId++, this._minBaseLocation = 0, e && (this._boundBufferBases[0] = null, this._minBaseLocation = 1, this._nextBindBaseIndex < 1 && (this._nextBindBaseIndex = 1));
+  }
+  freeLocationForBufferBase(e) {
+    let t = this.getLastBindBaseLocation(e);
+    if (t >= this._minBaseLocation)
+      return e._lastBindCallId = this._bindCallId, t;
+    let s = 0, n = this._nextBindBaseIndex;
+    for (; s < 2; ) {
+      n >= this._maxBindings && (n = this._minBaseLocation, s++);
+      const i = this._boundBufferBases[n];
+      if (i && i._lastBindCallId === this._bindCallId) {
+        n++;
+        continue;
+      }
+      break;
+    }
+    return t = n, this._nextBindBaseIndex = n + 1, s >= 2 ? -1 : (e._lastBindCallId = this._bindCallId, this._boundBufferBases[t] = null, t);
+  }
+  getLastBindBaseLocation(e) {
+    const t = e._lastBindBaseLocation;
+    return this._boundBufferBases[t] === e ? t : -1;
+  }
+  /**
+   * Binds a buffer whilst also binding its range.
+   * This will make the buffer start from the offset supplied rather than 0 when it is read.
+   * @param glBuffer - the buffer to bind
+   * @param index - the base index to bind at, defaults to 0
+   * @param offset - the offset to bind at (this is blocks of 256). 0 = 0, 1 = 256, 2 = 512 etc
+   * @param size - the size to bind at (this is blocks of 256).
+   */
+  bindBufferRange(e, t, s, n) {
+    const { _gl: i } = this;
+    s || (s = 0), t || (t = 0), this._boundBufferBases[t] = null, i.bindBufferRange(i.UNIFORM_BUFFER, t || 0, e.buffer, s * 256, n || 256);
+  }
+  /**
+   * Will ensure the data in the buffer is uploaded to the GPU.
+   * @param {Buffer} buffer - the buffer to update
+   */
+  updateBuffer(e) {
+    const { _gl: t } = this, s = this.getGlBuffer(e);
+    if (e._updateID === s.updateID)
+      return s;
+    s.updateID = e._updateID, t.bindBuffer(s.type, s.buffer);
+    const n = e.data, i = e.descriptor.usage & B.STATIC ? t.STATIC_DRAW : t.DYNAMIC_DRAW;
+    return n ? s.byteLength >= n.byteLength ? t.bufferSubData(s.type, 0, n, 0, e._updateSize / n.BYTES_PER_ELEMENT) : (s.byteLength = n.byteLength, t.bufferData(s.type, n, i)) : (s.byteLength = e.descriptor.size, t.bufferData(s.type, s.byteLength, i)), s;
+  }
+  /**
+   * dispose all WebGL resources of all managed buffers
+   * @param contextLost
+   */
+  destroyAll(e = !1) {
+    this._managedBuffers.removeAll(e);
+  }
+  onBufferUnload(e, t = !1) {
+    const s = e._gpuData[this._renderer.uid];
+    s && (t || this._gl.deleteBuffer(s.buffer));
+  }
+  /**
+   * creates and attaches a GLBuffer object tied to the current context.
+   * @param buffer
+   * @protected
+   */
+  createGLBuffer(e) {
+    const { _gl: t } = this;
+    let s = S.ARRAY_BUFFER;
+    e.descriptor.usage & B.INDEX ? s = S.ELEMENT_ARRAY_BUFFER : e.descriptor.usage & B.UNIFORM && (s = S.UNIFORM_BUFFER);
+    const n = new Ue(t.createBuffer(), s);
+    return e._gpuData[this._renderer.uid] = n, this._managedBuffers.add(e), n;
+  }
+  resetState() {
+    this._boundBufferBases = /* @__PURE__ */ Object.create(null);
+  }
+}
+j.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "buffer"
+};
+const F = class Y {
+  /** @param renderer - The renderer this System works for. */
+  constructor(e) {
+    this.supports = {
+      /** Support for 32-bit indices buffer. */
+      uint32Indices: !0,
+      /** Support for UniformBufferObjects */
+      uniformBufferObject: !0,
+      /** Support for VertexArrayObjects */
+      vertexArrayObject: !0,
+      /** Support for SRGB texture format */
+      srgbTextures: !0,
+      /** Support for wrapping modes if a texture is non-power of two */
+      nonPowOf2wrapping: !0,
+      /** Support for MSAA (antialiasing of dynamic textures) */
+      msaa: !0,
+      /** Support for mipmaps if a texture is non-power of two */
+      nonPowOf2mipmaps: !0
+    }, this._renderer = e, this.extensions = /* @__PURE__ */ Object.create(null), this.handleContextLost = this.handleContextLost.bind(this), this.handleContextRestored = this.handleContextRestored.bind(this);
+  }
+  /**
+   * `true` if the context is lost
+   * @readonly
+   */
+  get isLost() {
+    return !this.gl || this.gl.isContextLost();
+  }
+  /**
+   * Handles the context change event.
+   * @param {WebGLRenderingContext} gl - New WebGL context.
+   */
+  contextChange(e) {
+    this.gl = e, this._renderer.gl = e;
+  }
+  init(e) {
+    e = { ...Y.defaultOptions, ...e };
+    let t = this.multiView = e.multiView;
+    if (e.context && t && (p("Renderer created with both a context and multiview enabled. Disabling multiView as both cannot work together."), t = !1), t ? this.canvas = x.get().createCanvas(this._renderer.canvas.width, this._renderer.canvas.height) : this.canvas = this._renderer.view.canvas, e.context)
+      this.initFromContext(e.context);
+    else {
+      const s = this._renderer.background.alpha < 1, n = e.premultipliedAlpha ?? !0, i = e.antialias && !this._renderer.backBuffer.useBackBuffer;
+      this.createContext(e.preferWebGLVersion, {
+        alpha: s,
+        premultipliedAlpha: n,
+        antialias: i,
+        stencil: !0,
+        preserveDrawingBuffer: e.preserveDrawingBuffer,
+        powerPreference: e.powerPreference ?? "default"
+      });
+    }
+  }
+  ensureCanvasSize(e) {
+    if (!this.multiView) {
+      e !== this.canvas && p("multiView is disabled, but targetCanvas is not the main canvas");
+      return;
+    }
+    const { canvas: t } = this;
+    (t.width < e.width || t.height < e.height) && (t.width = Math.max(e.width, e.width), t.height = Math.max(e.height, e.height));
+  }
+  /**
+   * Initializes the context.
+   * @protected
+   * @param {WebGLRenderingContext} gl - WebGL context
+   */
+  initFromContext(e) {
+    this.gl = e, this.webGLVersion = e instanceof x.get().getWebGLRenderingContext() ? 1 : 2, this.getExtensions(), this.validateContext(e), this._renderer.runners.contextChange.emit(e);
+    const t = this._renderer.view.canvas;
+    t.addEventListener("webglcontextlost", this.handleContextLost, !1), t.addEventListener("webglcontextrestored", this.handleContextRestored, !1);
+  }
+  /**
+   * Initialize from context options
+   * @protected
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/getContext
+   * @param preferWebGLVersion
+   * @param {object} options - context attributes
+   */
+  createContext(e, t) {
+    let s;
+    const n = this.canvas;
+    if (e === 2 && (s = n.getContext("webgl2", t)), !s && (s = n.getContext("webgl", t), !s))
+      throw new Error("This browser does not support WebGL. Try using the canvas renderer");
+    this.gl = s, this.initFromContext(this.gl);
+  }
+  /** Auto-populate the {@link GlContextSystem.extensions extensions}. */
+  getExtensions() {
+    const { gl: e } = this, t = {
+      anisotropicFiltering: e.getExtension("EXT_texture_filter_anisotropic"),
+      floatTextureLinear: e.getExtension("OES_texture_float_linear"),
+      s3tc: e.getExtension("WEBGL_compressed_texture_s3tc"),
+      s3tc_sRGB: e.getExtension("WEBGL_compressed_texture_s3tc_srgb"),
+      // eslint-disable-line camelcase
+      etc: e.getExtension("WEBGL_compressed_texture_etc"),
+      etc1: e.getExtension("WEBGL_compressed_texture_etc1"),
+      pvrtc: e.getExtension("WEBGL_compressed_texture_pvrtc") || e.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc"),
+      atc: e.getExtension("WEBGL_compressed_texture_atc"),
+      astc: e.getExtension("WEBGL_compressed_texture_astc"),
+      bptc: e.getExtension("EXT_texture_compression_bptc"),
+      rgtc: e.getExtension("EXT_texture_compression_rgtc"),
+      loseContext: e.getExtension("WEBGL_lose_context")
+    };
+    if (this.webGLVersion === 1)
+      this.extensions = {
+        ...t,
+        drawBuffers: e.getExtension("WEBGL_draw_buffers"),
+        depthTexture: e.getExtension("WEBGL_depth_texture"),
+        vertexArrayObject: e.getExtension("OES_vertex_array_object") || e.getExtension("MOZ_OES_vertex_array_object") || e.getExtension("WEBKIT_OES_vertex_array_object"),
+        uint32ElementIndex: e.getExtension("OES_element_index_uint"),
+        // Floats and half-floats
+        floatTexture: e.getExtension("OES_texture_float"),
+        floatTextureLinear: e.getExtension("OES_texture_float_linear"),
+        textureHalfFloat: e.getExtension("OES_texture_half_float"),
+        textureHalfFloatLinear: e.getExtension("OES_texture_half_float_linear"),
+        vertexAttribDivisorANGLE: e.getExtension("ANGLE_instanced_arrays"),
+        srgb: e.getExtension("EXT_sRGB")
+      };
+    else {
+      this.extensions = {
+        ...t,
+        colorBufferFloat: e.getExtension("EXT_color_buffer_float")
+      };
+      const s = e.getExtension("WEBGL_provoking_vertex");
+      s && s.provokingVertexWEBGL(s.FIRST_VERTEX_CONVENTION_WEBGL);
+    }
+  }
+  /**
+   * Handles a lost webgl context
+   * @param {WebGLContextEvent} event - The context lost event.
+   */
+  handleContextLost(e) {
+    e.preventDefault(), this._contextLossForced && (this._contextLossForced = !1, setTimeout(() => {
+      var t;
+      this.gl.isContextLost() && ((t = this.extensions.loseContext) == null || t.restoreContext());
+    }, 0));
+  }
+  /** Handles a restored webgl context. */
+  handleContextRestored() {
+    this.getExtensions(), this._renderer.runners.contextChange.emit(this.gl);
+  }
+  destroy() {
+    var t;
+    const e = this._renderer.view.canvas;
+    this._renderer = null, e.removeEventListener("webglcontextlost", this.handleContextLost), e.removeEventListener("webglcontextrestored", this.handleContextRestored), this.gl.useProgram(null), (t = this.extensions.loseContext) == null || t.loseContext();
+  }
+  /**
+   * this function can be called to force a webGL context loss
+   * this will release all resources on the GPU.
+   * Useful if you need to put Pixi to sleep, and save some GPU memory
+   *
+   * As soon as render is called - all resources will be created again.
+   */
+  forceContextLoss() {
+    var e;
+    (e = this.extensions.loseContext) == null || e.loseContext(), this._contextLossForced = !0;
+  }
+  /**
+   * Validate context.
+   * @param {WebGLRenderingContext} gl - Render context.
+   */
+  validateContext(e) {
+    const t = e.getContextAttributes();
+    t && !t.stencil && p("Provided WebGL context does not have a stencil buffer, masks may not render correctly");
+    const s = this.supports, n = this.webGLVersion === 2, i = this.extensions;
+    s.uint32Indices = n || !!i.uint32ElementIndex, s.uniformBufferObject = n, s.vertexArrayObject = n || !!i.vertexArrayObject, s.srgbTextures = n || !!i.srgb, s.nonPowOf2wrapping = n, s.nonPowOf2mipmaps = n, s.msaa = n, s.uint32Indices || p("Provided WebGL context does not support 32 index buffer, large scenes may not render correctly");
+  }
+};
+F.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "context"
+};
+F.defaultOptions = {
+  /**
+   * {@link WebGLOptions.context}
+   * @default null
+   */
+  context: null,
+  /**
+   * {@link WebGLOptions.premultipliedAlpha}
+   * @default true
+   */
+  premultipliedAlpha: !0,
+  /**
+   * {@link WebGLOptions.preserveDrawingBuffer}
+   * @default false
+   */
+  preserveDrawingBuffer: !1,
+  /**
+   * {@link WebGLOptions.powerPreference}
+   * @default default
+   */
+  powerPreference: void 0,
+  /**
+   * {@link WebGLOptions.webGLVersion}
+   * @default 2
+   */
+  preferWebGLVersion: 2,
+  /**
+   * {@link WebGLOptions.multiView}
+   * @default false
+   */
+  multiView: !1
+};
+let ye = F;
+var G = /* @__PURE__ */ ((r) => (r[r.RGBA = 6408] = "RGBA", r[r.RGB = 6407] = "RGB", r[r.RG = 33319] = "RG", r[r.RED = 6403] = "RED", r[r.RGBA_INTEGER = 36249] = "RGBA_INTEGER", r[r.RGB_INTEGER = 36248] = "RGB_INTEGER", r[r.RG_INTEGER = 33320] = "RG_INTEGER", r[r.RED_INTEGER = 36244] = "RED_INTEGER", r[r.ALPHA = 6406] = "ALPHA", r[r.LUMINANCE = 6409] = "LUMINANCE", r[r.LUMINANCE_ALPHA = 6410] = "LUMINANCE_ALPHA", r[r.DEPTH_COMPONENT = 6402] = "DEPTH_COMPONENT", r[r.DEPTH_STENCIL = 34041] = "DEPTH_STENCIL", r))(G || {}), M = /* @__PURE__ */ ((r) => (r[r.TEXTURE_2D = 3553] = "TEXTURE_2D", r[r.TEXTURE_CUBE_MAP = 34067] = "TEXTURE_CUBE_MAP", r[r.TEXTURE_2D_ARRAY = 35866] = "TEXTURE_2D_ARRAY", r[r.TEXTURE_CUBE_MAP_POSITIVE_X = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X", r[r.TEXTURE_CUBE_MAP_NEGATIVE_X = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X", r[r.TEXTURE_CUBE_MAP_POSITIVE_Y = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y", r[r.TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y", r[r.TEXTURE_CUBE_MAP_POSITIVE_Z = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z", r[r.TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z", r))(M || {}), d = /* @__PURE__ */ ((r) => (r[r.UNSIGNED_BYTE = 5121] = "UNSIGNED_BYTE", r[r.UNSIGNED_SHORT = 5123] = "UNSIGNED_SHORT", r[r.UNSIGNED_SHORT_5_6_5 = 33635] = "UNSIGNED_SHORT_5_6_5", r[r.UNSIGNED_SHORT_4_4_4_4 = 32819] = "UNSIGNED_SHORT_4_4_4_4", r[r.UNSIGNED_SHORT_5_5_5_1 = 32820] = "UNSIGNED_SHORT_5_5_5_1", r[r.UNSIGNED_INT = 5125] = "UNSIGNED_INT", r[r.UNSIGNED_INT_10F_11F_11F_REV = 35899] = "UNSIGNED_INT_10F_11F_11F_REV", r[r.UNSIGNED_INT_2_10_10_10_REV = 33640] = "UNSIGNED_INT_2_10_10_10_REV", r[r.UNSIGNED_INT_24_8 = 34042] = "UNSIGNED_INT_24_8", r[r.UNSIGNED_INT_5_9_9_9_REV = 35902] = "UNSIGNED_INT_5_9_9_9_REV", r[r.BYTE = 5120] = "BYTE", r[r.SHORT = 5122] = "SHORT", r[r.INT = 5124] = "INT", r[r.FLOAT = 5126] = "FLOAT", r[r.FLOAT_32_UNSIGNED_INT_24_8_REV = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV", r[r.HALF_FLOAT = 36193] = "HALF_FLOAT", r))(d || {});
+const P = {
+  uint8x2: d.UNSIGNED_BYTE,
+  uint8x4: d.UNSIGNED_BYTE,
+  sint8x2: d.BYTE,
+  sint8x4: d.BYTE,
+  unorm8x2: d.UNSIGNED_BYTE,
+  unorm8x4: d.UNSIGNED_BYTE,
+  snorm8x2: d.BYTE,
+  snorm8x4: d.BYTE,
+  uint16x2: d.UNSIGNED_SHORT,
+  uint16x4: d.UNSIGNED_SHORT,
+  sint16x2: d.SHORT,
+  sint16x4: d.SHORT,
+  unorm16x2: d.UNSIGNED_SHORT,
+  unorm16x4: d.UNSIGNED_SHORT,
+  snorm16x2: d.SHORT,
+  snorm16x4: d.SHORT,
+  float16x2: d.HALF_FLOAT,
+  float16x4: d.HALF_FLOAT,
+  float32: d.FLOAT,
+  float32x2: d.FLOAT,
+  float32x3: d.FLOAT,
+  float32x4: d.FLOAT,
+  uint32: d.UNSIGNED_INT,
+  uint32x2: d.UNSIGNED_INT,
+  uint32x3: d.UNSIGNED_INT,
+  uint32x4: d.UNSIGNED_INT,
+  sint32: d.INT,
+  sint32x2: d.INT,
+  sint32x3: d.INT,
+  sint32x4: d.INT
+};
+function Fe(r) {
+  return P[r] ?? P.float32;
+}
+const Me = {
+  "point-list": 0,
+  "line-list": 1,
+  "line-strip": 3,
+  "triangle-list": 4,
+  "triangle-strip": 5
+};
+class Oe {
+  constructor() {
+    this.vaoCache = /* @__PURE__ */ Object.create(null);
+  }
+  destroy() {
+    this.vaoCache = /* @__PURE__ */ Object.create(null);
+  }
+}
+class z {
+  /** @param renderer - The renderer this System works for. */
+  constructor(e) {
+    this._renderer = e, this._activeGeometry = null, this._activeVao = null, this.hasVao = !0, this.hasInstance = !0, this._managedGeometries = new D({
+      renderer: e,
+      type: "resource",
+      onUnload: this.onGeometryUnload.bind(this),
+      name: "glGeometry"
+    });
+  }
+  /** Sets up the renderer context and necessary buffers. */
+  contextChange() {
+    const e = this.gl = this._renderer.gl;
+    if (!this._renderer.context.supports.vertexArrayObject)
+      throw new Error("[PixiJS] Vertex Array Objects are not supported on this device");
+    this.destroyAll(!0);
+    const t = this._renderer.context.extensions.vertexArrayObject;
+    t && (e.createVertexArray = () => t.createVertexArrayOES(), e.bindVertexArray = (n) => t.bindVertexArrayOES(n), e.deleteVertexArray = (n) => t.deleteVertexArrayOES(n));
+    const s = this._renderer.context.extensions.vertexAttribDivisorANGLE;
+    s && (e.drawArraysInstanced = (n, i, a, o) => {
+      s.drawArraysInstancedANGLE(n, i, a, o);
+    }, e.drawElementsInstanced = (n, i, a, o, c) => {
+      s.drawElementsInstancedANGLE(n, i, a, o, c);
+    }, e.vertexAttribDivisor = (n, i) => s.vertexAttribDivisorANGLE(n, i)), this._activeGeometry = null, this._activeVao = null;
+  }
+  /**
+   * Binds geometry so that is can be drawn. Creating a Vao if required
+   * @param geometry - Instance of geometry to bind.
+   * @param program - Instance of program to use vao for.
+   */
+  bind(e, t) {
+    const s = this.gl;
+    this._activeGeometry = e;
+    const n = this.getVao(e, t);
+    this._activeVao !== n && (this._activeVao = n, s.bindVertexArray(n)), this.updateBuffers();
+  }
+  /** Reset and unbind any active VAO and geometry. */
+  resetState() {
+    this.unbind();
+  }
+  /** Update buffers of the currently bound geometry. */
+  updateBuffers() {
+    const e = this._activeGeometry, t = this._renderer.buffer;
+    for (let s = 0; s < e.buffers.length; s++) {
+      const n = e.buffers[s];
+      t.updateBuffer(n);
+    }
+    e._gcLastUsed = this._renderer.gc.now;
+  }
+  /**
+   * Check compatibility between a geometry and a program
+   * @param geometry - Geometry instance.
+   * @param program - Program instance.
+   */
+  checkCompatibility(e, t) {
+    const s = e.attributes, n = t._attributeData;
+    for (const i in n)
+      if (!s[i])
+        throw new Error(`shader and geometry incompatible, geometry missing the "${i}" attribute`);
+  }
+  /**
+   * Takes a geometry and program and generates a unique signature for them.
+   * @param geometry - To get signature from.
+   * @param program - To test geometry against.
+   * @returns - Unique signature of the geometry and program
+   */
+  getSignature(e, t) {
+    const s = e.attributes, n = t._attributeData, i = ["g", e.uid];
+    for (const a in s)
+      n[a] && i.push(a, n[a].location);
+    return i.join("-");
+  }
+  getVao(e, t) {
+    var s;
+    return ((s = e._gpuData[this._renderer.uid]) == null ? void 0 : s.vaoCache[t._key]) || this.initGeometryVao(e, t);
+  }
+  /**
+   * Creates or gets Vao with the same structure as the geometry and stores it on the geometry.
+   * If vao is created, it is bound automatically. We use a shader to infer what and how to set up the
+   * attribute locations.
+   * @param geometry - Instance of geometry to to generate Vao for.
+   * @param program
+   * @param _incRefCount - Increment refCount of all geometry buffers.
+   */
+  initGeometryVao(e, t, s = !0) {
+    const n = this._renderer.gl, i = this._renderer.buffer;
+    this._renderer.shader._getProgramData(t), this.checkCompatibility(e, t);
+    const a = this.getSignature(e, t);
+    let o = e._gpuData[this._renderer.uid];
+    o || (o = new Oe(), e._gpuData[this._renderer.uid] = o, this._managedGeometries.add(e));
+    const c = o.vaoCache;
+    let _ = c[a];
+    if (_)
+      return c[t._key] = _, _;
+    Ae(e, t._attributeData);
+    const h = e.buffers;
+    _ = n.createVertexArray(), n.bindVertexArray(_);
+    for (let u = 0; u < h.length; u++) {
+      const l = h[u];
+      i.bind(l);
+    }
+    return this.activateVao(e, t), c[t._key] = _, c[a] = _, n.bindVertexArray(null), _;
+  }
+  onGeometryUnload(e, t = !1) {
+    const s = e._gpuData[this._renderer.uid];
+    if (!s) return;
+    const n = s.vaoCache;
+    if (!t)
+      for (const i in n)
+        this._activeVao !== n[i] && this.resetState(), this.gl.deleteVertexArray(n[i]);
+  }
+  /**
+   * Dispose all WebGL resources of all managed geometries.
+   * @param [contextLost=false] - If context was lost, we suppress `gl.delete` calls
+   */
+  destroyAll(e = !1) {
+    this._managedGeometries.removeAll(e);
+  }
+  /**
+   * Activate vertex array object.
+   * @param geometry - Geometry instance.
+   * @param program - Shader program instance.
+   */
+  activateVao(e, t) {
+    var o;
+    const s = this._renderer.gl, n = this._renderer.buffer, i = e.attributes;
+    e.indexBuffer && n.bind(e.indexBuffer);
+    let a = null;
+    for (const c in i) {
+      const _ = i[c], h = _.buffer, u = n.getGlBuffer(h), l = t._attributeData[c];
+      if (l) {
+        a !== u && (n.bind(h), a = u);
+        const E = l.location;
+        s.enableVertexAttribArray(E);
+        const b = he(_.format), m = Fe(_.format);
+        if (((o = l.format) == null ? void 0 : o.substring(1, 4)) === "int" ? s.vertexAttribIPointer(
+          E,
+          b.size,
+          m,
+          _.stride,
+          _.offset
+        ) : s.vertexAttribPointer(
+          E,
+          b.size,
+          m,
+          b.normalised,
+          _.stride,
+          _.offset
+        ), _.instance)
+          if (this.hasInstance) {
+            const ce = _.divisor ?? 1;
+            s.vertexAttribDivisor(E, ce);
+          } else
+            throw new Error("geometry error, GPU Instancing is not supported on this device");
+      }
+    }
+  }
+  /**
+   * Draws the currently bound geometry.
+   * @param topology - The type primitive to render.
+   * @param size - The number of elements to be rendered. If not specified, all vertices after the
+   *  starting vertex will be drawn.
+   * @param start - The starting vertex in the geometry to start drawing from. If not specified,
+   *  drawing will start from the first vertex.
+   * @param instanceCount - The number of instances of the set of elements to execute. If not specified,
+   *  all instances will be drawn.
+   * @returns This instance of the geometry system.
+   */
+  draw(e, t, s, n) {
+    const { gl: i } = this._renderer, a = this._activeGeometry, o = Me[e || a.topology];
+    if (n ?? (n = a.instanceCount), a.indexBuffer) {
+      const c = a.indexBuffer.data.BYTES_PER_ELEMENT, _ = c === 2 ? i.UNSIGNED_SHORT : i.UNSIGNED_INT;
+      n !== 1 ? i.drawElementsInstanced(o, t || a.indexBuffer.data.length, _, (s || 0) * c, n) : i.drawElements(o, t || a.indexBuffer.data.length, _, (s || 0) * c);
+    } else n !== 1 ? i.drawArraysInstanced(o, s || 0, t || a.getSize(), n) : i.drawArrays(o, s || 0, t || a.getSize());
+    return this;
+  }
+  /** Unbind/reset everything. */
+  unbind() {
+    this.gl.bindVertexArray(null), this._activeVao = null, this._activeGeometry = null;
+  }
+  destroy() {
+    this._managedGeometries.destroy(), this._renderer = null, this.gl = null, this._activeVao = null, this._activeGeometry = null;
+  }
+}
+z.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "geometry"
+};
+const Le = new ue({
+  attributes: {
+    aPosition: [
+      -1,
+      -1,
+      // Bottom left corner
+      3,
+      -1,
+      // Bottom right corner, extending beyond right edge
+      -1,
+      3
+      // Top left corner, extending beyond top edge
+    ]
+  }
+}), O = class q {
+  constructor(e) {
+    this.useBackBuffer = !1, this._useBackBufferThisRender = !1, this._renderer = e;
+  }
+  init(e = {}) {
+    const { useBackBuffer: t, antialias: s } = { ...q.defaultOptions, ...e };
+    this.useBackBuffer = t, this._antialias = s, this._renderer.context.supports.msaa || (p("antialiasing, is not supported on when using the back buffer"), this._antialias = !1), this._state = U.for2d();
+    const n = new Ge({
+      vertex: `
+                attribute vec2 aPosition;
+                out vec2 vUv;
+
+                void main() {
+                    gl_Position = vec4(aPosition, 0.0, 1.0);
+
+                    vUv = (aPosition + 1.0) / 2.0;
+
+                    // flip dem UVs
+                    vUv.y = 1.0 - vUv.y;
+                }`,
+      fragment: `
+                in vec2 vUv;
+                out vec4 finalColor;
+
+                uniform sampler2D uTexture;
+
+                void main() {
+                    finalColor = texture(uTexture, vUv);
+                }`,
+      name: "big-triangle"
+    });
+    this._bigTriangleShader = new y({
+      glProgram: n,
+      resources: {
+        uTexture: R.WHITE.source
+      }
+    });
+  }
+  /**
+   * This is called before the RenderTargetSystem is started. This is where
+   * we replace the target with the back buffer if required.
+   * @param options - The options for this render.
+   */
+  renderStart(e) {
+    const t = this._renderer.renderTarget.getRenderTarget(e.target);
+    if (this._useBackBufferThisRender = this.useBackBuffer && !!t.isRoot, this._useBackBufferThisRender) {
+      const s = this._renderer.renderTarget.getRenderTarget(e.target);
+      this._targetTexture = s.colorTexture, e.target = this._getBackBufferTexture(s.colorTexture);
+    }
+  }
+  renderEnd() {
+    this._presentBackBuffer();
+  }
+  _presentBackBuffer() {
+    const e = this._renderer;
+    e.renderTarget.finishRenderPass(), this._useBackBufferThisRender && (e.renderTarget.bind(this._targetTexture, !1), this._bigTriangleShader.resources.uTexture = this._backBufferTexture.source, e.encoder.draw({
+      geometry: Le,
+      shader: this._bigTriangleShader,
+      state: this._state
+    }));
+  }
+  _getBackBufferTexture(e) {
+    return this._backBufferTexture = this._backBufferTexture || new R({
+      source: new de({
+        width: e.width,
+        height: e.height,
+        resolution: e._resolution,
+        antialias: this._antialias
+      })
+    }), this._backBufferTexture.source.resize(
+      e.width,
+      e.height,
+      e._resolution
+    ), this._backBufferTexture;
+  }
+  /** destroys the back buffer */
+  destroy() {
+    this._backBufferTexture && (this._backBufferTexture.destroy(), this._backBufferTexture = null);
+  }
+};
+O.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "backBuffer",
+  priority: 1
+};
+O.defaultOptions = {
+  /** if true will use the back buffer where required */
+  useBackBuffer: !1
+};
+let Pe = O;
+class Z {
+  constructor(e) {
+    this._colorMaskCache = 15, this._renderer = e;
+  }
+  setMask(e) {
+    this._colorMaskCache !== e && (this._colorMaskCache = e, this._renderer.gl.colorMask(
+      !!(e & 8),
+      !!(e & 4),
+      !!(e & 2),
+      !!(e & 1)
+    ));
+  }
+}
+Z.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "colorMask"
+};
+class $ {
+  constructor(e) {
+    this.commandFinished = Promise.resolve(), this._renderer = e;
+  }
+  setGeometry(e, t) {
+    this._renderer.geometry.bind(e, t.glProgram);
+  }
+  finishRenderPass() {
+  }
+  draw(e) {
+    const t = this._renderer, { geometry: s, shader: n, state: i, skipSync: a, topology: o, size: c, start: _, instanceCount: h } = e;
+    t.shader.bind(n, a), t.geometry.bind(s, t.shader._activeProgram), i && t.state.set(i), t.geometry.draw(o, c, _, h ?? s.instanceCount);
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+$.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "encoder"
+};
+class Q {
+  constructor(e) {
+    this._renderer = e;
+  }
+  contextChange() {
+    const e = this._renderer.gl;
+    this.maxTextures = e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS), this.maxBatchableTextures = pe(this.maxTextures, e);
+    const t = this._renderer.context.webGLVersion === 2;
+    this.maxUniformBindings = t ? e.getParameter(e.MAX_UNIFORM_BUFFER_BINDINGS) : 0;
+  }
+  destroy() {
+  }
+}
+Q.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "limits"
+};
+class we {
+  constructor() {
+    this.width = -1, this.height = -1, this.msaa = !1, this._attachedMipLevel = 0, this._attachedLayer = 0, this.msaaRenderBuffer = [];
+  }
+}
+class J {
+  constructor(e) {
+    this._stencilCache = {
+      enabled: !1,
+      stencilReference: 0,
+      stencilMode: T.NONE
+    }, this._renderTargetStencilState = /* @__PURE__ */ Object.create(null), e.renderTarget.onRenderTargetChange.add(this);
+  }
+  contextChange(e) {
+    this._gl = e, this._comparisonFuncMapping = {
+      always: e.ALWAYS,
+      never: e.NEVER,
+      equal: e.EQUAL,
+      "not-equal": e.NOTEQUAL,
+      less: e.LESS,
+      "less-equal": e.LEQUAL,
+      greater: e.GREATER,
+      "greater-equal": e.GEQUAL
+    }, this._stencilOpsMapping = {
+      keep: e.KEEP,
+      zero: e.ZERO,
+      replace: e.REPLACE,
+      invert: e.INVERT,
+      "increment-clamp": e.INCR,
+      "decrement-clamp": e.DECR,
+      "increment-wrap": e.INCR_WRAP,
+      "decrement-wrap": e.DECR_WRAP
+    }, this.resetState();
+  }
+  onRenderTargetChange(e) {
+    if (this._activeRenderTarget === e) return;
+    this._activeRenderTarget = e;
+    let t = this._renderTargetStencilState[e.uid];
+    t || (t = this._renderTargetStencilState[e.uid] = {
+      stencilMode: T.DISABLED,
+      stencilReference: 0
+    }), this.setStencilMode(t.stencilMode, t.stencilReference);
+  }
+  resetState() {
+    this._stencilCache.enabled = !1, this._stencilCache.stencilMode = T.NONE, this._stencilCache.stencilReference = 0;
+  }
+  setStencilMode(e, t) {
+    const s = this._renderTargetStencilState[this._activeRenderTarget.uid], n = this._gl, i = Ce[e], a = this._stencilCache;
+    if (s.stencilMode = e, s.stencilReference = t, e === T.DISABLED) {
+      this._stencilCache.enabled && (this._stencilCache.enabled = !1, n.disable(n.STENCIL_TEST));
+      return;
+    }
+    this._stencilCache.enabled || (this._stencilCache.enabled = !0, n.enable(n.STENCIL_TEST)), (e !== a.stencilMode || a.stencilReference !== t) && (a.stencilMode = e, a.stencilReference = t, n.stencilFunc(this._comparisonFuncMapping[i.stencilBack.compare], t, 255), n.stencilOp(n.KEEP, n.KEEP, this._stencilOpsMapping[i.stencilBack.passOp]));
+  }
+}
+J.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "stencil"
+};
+class ve {
+  constructor() {
+    this._clearColorCache = [0, 0, 0, 0], this._viewPortCache = new L();
+  }
+  init(e, t) {
+    this._renderer = e, this._renderTargetSystem = t, e.runners.contextChange.add(this);
+  }
+  contextChange() {
+    this._clearColorCache = [0, 0, 0, 0], this._viewPortCache = new L();
+    const e = this._renderer.gl;
+    this._drawBuffersCache = [];
+    for (let t = 1; t <= 16; t++)
+      this._drawBuffersCache[t] = Array.from({ length: t }, (s, n) => e.COLOR_ATTACHMENT0 + n);
+  }
+  copyToTexture(e, t, s, n, i) {
+    const a = this._renderTargetSystem, o = this._renderer, c = a.getGpuRenderTarget(e), _ = o.gl;
+    return this.finishRenderPass(e), _.bindFramebuffer(_.FRAMEBUFFER, c.resolveTargetFramebuffer), o.texture.bind(t, 0), _.copyTexSubImage2D(
+      _.TEXTURE_2D,
+      0,
+      i.x,
+      i.y,
+      s.x,
+      s.y,
+      n.width,
+      n.height
+    ), t;
+  }
+  startRenderPass(e, t = !0, s, n, i = 0, a = 0) {
+    const o = this._renderTargetSystem, c = e.colorTexture, _ = o.getGpuRenderTarget(e);
+    if (a !== 0 && this._renderer.context.webGLVersion < 2)
+      throw new Error("[RenderTargetSystem] Rendering to array layers requires WebGL2.");
+    if (i > 0) {
+      if (_.msaa)
+        throw new Error("[RenderTargetSystem] Rendering to mip levels is not supported with MSAA render targets.");
+      if (this._renderer.context.webGLVersion < 2)
+        throw new Error("[RenderTargetSystem] Rendering to mip levels requires WebGL2.");
+    }
+    let h = n.y;
+    e.isRoot && (h = c.pixelHeight - n.height - n.y), e.colorTextures.forEach((E) => {
+      this._renderer.texture.unbind(E);
+    });
+    const u = this._renderer.gl;
+    u.bindFramebuffer(u.FRAMEBUFFER, _.framebuffer), !e.isRoot && (_._attachedMipLevel !== i || _._attachedLayer !== a) && (e.colorTextures.forEach((E, b) => {
+      const m = this._renderer.texture.getGlSource(E);
+      if (m.target === u.TEXTURE_2D) {
+        if (a !== 0)
+          throw new Error("[RenderTargetSystem] layer must be 0 when rendering to 2D textures in WebGL.");
+        u.framebufferTexture2D(
+          u.FRAMEBUFFER,
+          u.COLOR_ATTACHMENT0 + b,
+          u.TEXTURE_2D,
+          m.texture,
+          i
+        );
+      } else if (m.target === u.TEXTURE_2D_ARRAY) {
+        if (this._renderer.context.webGLVersion < 2)
+          throw new Error("[RenderTargetSystem] Rendering to 2D array textures requires WebGL2.");
+        u.framebufferTextureLayer(
+          u.FRAMEBUFFER,
+          u.COLOR_ATTACHMENT0 + b,
+          m.texture,
+          i,
+          a
+        );
+      } else if (m.target === u.TEXTURE_CUBE_MAP) {
+        if (a < 0 || a > 5)
+          throw new Error("[RenderTargetSystem] Cube map layer must be between 0 and 5.");
+        u.framebufferTexture2D(
+          u.FRAMEBUFFER,
+          u.COLOR_ATTACHMENT0 + b,
+          u.TEXTURE_CUBE_MAP_POSITIVE_X + a,
+          m.texture,
+          i
+        );
+      } else
+        throw new Error("[RenderTargetSystem] Unsupported texture target for render-to-layer in WebGL.");
+    }), _._attachedMipLevel = i, _._attachedLayer = a), e.colorTextures.length > 1 && this._setDrawBuffers(e, u);
+    const l = this._viewPortCache;
+    (l.x !== n.x || l.y !== h || l.width !== n.width || l.height !== n.height) && (l.x = n.x, l.y = h, l.width = n.width, l.height = n.height, u.viewport(
+      n.x,
+      h,
+      n.width,
+      n.height
+    )), !_.depthStencilRenderBuffer && (e.stencil || e.depth) && this._initStencil(_), this.clear(e, t, s);
+  }
+  finishRenderPass(e) {
+    const s = this._renderTargetSystem.getGpuRenderTarget(e);
+    if (!s.msaa) return;
+    const n = this._renderer.gl;
+    n.bindFramebuffer(n.FRAMEBUFFER, s.resolveTargetFramebuffer), n.bindFramebuffer(n.READ_FRAMEBUFFER, s.framebuffer), n.blitFramebuffer(
+      0,
+      0,
+      s.width,
+      s.height,
+      0,
+      0,
+      s.width,
+      s.height,
+      n.COLOR_BUFFER_BIT,
+      n.NEAREST
+    ), n.bindFramebuffer(n.FRAMEBUFFER, s.framebuffer);
+  }
+  initGpuRenderTarget(e) {
+    const s = this._renderer.gl, n = new we();
+    return n._attachedMipLevel = 0, n._attachedLayer = 0, e.colorTexture instanceof A ? (this._renderer.context.ensureCanvasSize(e.colorTexture.resource), n.framebuffer = null, n) : (this._initColor(e, n), s.bindFramebuffer(s.FRAMEBUFFER, null), n);
+  }
+  destroyGpuRenderTarget(e) {
+    const t = this._renderer.gl;
+    e.framebuffer && (t.deleteFramebuffer(e.framebuffer), e.framebuffer = null), e.resolveTargetFramebuffer && (t.deleteFramebuffer(e.resolveTargetFramebuffer), e.resolveTargetFramebuffer = null), e.depthStencilRenderBuffer && (t.deleteRenderbuffer(e.depthStencilRenderBuffer), e.depthStencilRenderBuffer = null), e.msaaRenderBuffer.forEach((s) => {
+      t.deleteRenderbuffer(s);
+    }), e.msaaRenderBuffer = null;
+  }
+  clear(e, t, s, n, i = 0, a = 0) {
+    if (!t) return;
+    if (a !== 0)
+      throw new Error("[RenderTargetSystem] Clearing array layers is not supported in WebGL renderer.");
+    const o = this._renderTargetSystem;
+    typeof t == "boolean" && (t = t ? C.ALL : C.NONE);
+    const c = this._renderer.gl;
+    if (t & C.COLOR) {
+      s ?? (s = o.defaultClearColor);
+      const _ = this._clearColorCache, h = s;
+      (_[0] !== h[0] || _[1] !== h[1] || _[2] !== h[2] || _[3] !== h[3]) && (_[0] = h[0], _[1] = h[1], _[2] = h[2], _[3] = h[3], c.clearColor(h[0], h[1], h[2], h[3]));
+    }
+    c.clear(t);
+  }
+  resizeGpuRenderTarget(e) {
+    if (e.isRoot) return;
+    const s = this._renderTargetSystem.getGpuRenderTarget(e);
+    this._resizeColor(e, s), (e.stencil || e.depth) && this._resizeStencil(s);
+  }
+  _initColor(e, t) {
+    const s = this._renderer, n = s.gl, i = n.createFramebuffer();
+    if (t.resolveTargetFramebuffer = i, n.bindFramebuffer(n.FRAMEBUFFER, i), t.width = e.colorTexture.source.pixelWidth, t.height = e.colorTexture.source.pixelHeight, e.colorTextures.forEach((o, c) => {
+      const _ = o.source;
+      _.antialias && (s.context.supports.msaa ? t.msaa = !0 : p("[RenderTexture] Antialiasing on textures is not supported in WebGL1")), s.texture.bindSource(_, 0);
+      const h = s.texture.getGlSource(_), u = h.texture;
+      if (h.target === n.TEXTURE_2D)
+        n.framebufferTexture2D(
+          n.FRAMEBUFFER,
+          n.COLOR_ATTACHMENT0 + c,
+          n.TEXTURE_2D,
+          u,
+          0
+        );
+      else if (h.target === n.TEXTURE_2D_ARRAY) {
+        if (s.context.webGLVersion < 2)
+          throw new Error("[RenderTargetSystem] TEXTURE_2D_ARRAY requires WebGL2.");
+        n.framebufferTextureLayer(
+          n.FRAMEBUFFER,
+          n.COLOR_ATTACHMENT0 + c,
+          u,
+          0,
+          0
+        );
+      } else if (h.target === n.TEXTURE_CUBE_MAP)
+        n.framebufferTexture2D(
+          n.FRAMEBUFFER,
+          n.COLOR_ATTACHMENT0 + c,
+          n.TEXTURE_CUBE_MAP_POSITIVE_X,
+          u,
+          0
+        );
+      else
+        throw new Error("[RenderTargetSystem] Unsupported texture target for framebuffer attachment.");
+    }), t.msaa) {
+      const o = n.createFramebuffer();
+      t.framebuffer = o, n.bindFramebuffer(n.FRAMEBUFFER, o), e.colorTextures.forEach((c, _) => {
+        const h = n.createRenderbuffer();
+        t.msaaRenderBuffer[_] = h;
+      });
+    } else
+      t.framebuffer = i;
+    this._resizeColor(e, t);
+  }
+  _resizeColor(e, t) {
+    const s = e.colorTexture.source;
+    if (t.width = s.pixelWidth, t.height = s.pixelHeight, t._attachedMipLevel = 0, t._attachedLayer = 0, e.colorTextures.forEach((n, i) => {
+      i !== 0 && n.source.resize(s.width, s.height, s._resolution);
+    }), t.msaa) {
+      const n = this._renderer, i = n.gl, a = t.framebuffer;
+      i.bindFramebuffer(i.FRAMEBUFFER, a), e.colorTextures.forEach((o, c) => {
+        const _ = o.source;
+        n.texture.bindSource(_, 0);
+        const u = n.texture.getGlSource(_).internalFormat, l = t.msaaRenderBuffer[c];
+        i.bindRenderbuffer(
+          i.RENDERBUFFER,
+          l
+        ), i.renderbufferStorageMultisample(
+          i.RENDERBUFFER,
+          4,
+          u,
+          _.pixelWidth,
+          _.pixelHeight
+        ), i.framebufferRenderbuffer(
+          i.FRAMEBUFFER,
+          i.COLOR_ATTACHMENT0 + c,
+          i.RENDERBUFFER,
+          l
+        );
+      });
+    }
+  }
+  _initStencil(e) {
+    if (e.framebuffer === null) return;
+    const t = this._renderer.gl, s = t.createRenderbuffer();
+    e.depthStencilRenderBuffer = s, t.bindRenderbuffer(
+      t.RENDERBUFFER,
+      s
+    ), t.framebufferRenderbuffer(
+      t.FRAMEBUFFER,
+      t.DEPTH_STENCIL_ATTACHMENT,
+      t.RENDERBUFFER,
+      s
+    ), this._resizeStencil(e);
+  }
+  _resizeStencil(e) {
+    const t = this._renderer.gl;
+    t.bindRenderbuffer(
+      t.RENDERBUFFER,
+      e.depthStencilRenderBuffer
+    ), e.msaa ? t.renderbufferStorageMultisample(
+      t.RENDERBUFFER,
+      4,
+      t.DEPTH24_STENCIL8,
+      e.width,
+      e.height
+    ) : t.renderbufferStorage(
+      t.RENDERBUFFER,
+      this._renderer.context.webGLVersion === 2 ? t.DEPTH24_STENCIL8 : t.DEPTH_STENCIL,
+      e.width,
+      e.height
+    );
+  }
+  prerender(e) {
+    const t = e.colorTexture.resource;
+    this._renderer.context.multiView && A.test(t) && this._renderer.context.ensureCanvasSize(t);
+  }
+  postrender(e) {
+    if (this._renderer.context.multiView && A.test(e.colorTexture.resource)) {
+      const t = this._renderer.context.canvas, s = e.colorTexture;
+      s.context2D.drawImage(
+        t,
+        0,
+        s.pixelHeight - t.height
+      );
+    }
+  }
+  _setDrawBuffers(e, t) {
+    const s = e.colorTextures.length, n = this._drawBuffersCache[s];
+    if (this._renderer.context.webGLVersion === 1) {
+      const i = this._renderer.context.extensions.drawBuffers;
+      i ? i.drawBuffersWEBGL(n) : p("[RenderTexture] This WebGL1 context does not support rendering to multiple targets");
+    } else
+      t.drawBuffers(n);
+  }
+}
+class ee extends Re {
+  constructor(e) {
+    super(e), this.adaptor = new ve(), this.adaptor.init(e, this);
+  }
+}
+ee.extension = {
+  type: [f.WebGLSystem],
+  name: "renderTarget"
+};
+function He(r) {
+  const e = {};
+  if (e.normal = [r.ONE, r.ONE_MINUS_SRC_ALPHA], e.add = [r.ONE, r.ONE], e.multiply = [r.DST_COLOR, r.ONE_MINUS_SRC_ALPHA, r.ONE, r.ONE_MINUS_SRC_ALPHA], e.screen = [r.ONE, r.ONE_MINUS_SRC_COLOR, r.ONE, r.ONE_MINUS_SRC_ALPHA], e.none = [0, 0], e["normal-npm"] = [r.SRC_ALPHA, r.ONE_MINUS_SRC_ALPHA, r.ONE, r.ONE_MINUS_SRC_ALPHA], e["add-npm"] = [r.SRC_ALPHA, r.ONE, r.ONE, r.ONE], e["screen-npm"] = [r.SRC_ALPHA, r.ONE_MINUS_SRC_COLOR, r.ONE, r.ONE_MINUS_SRC_ALPHA], e.erase = [r.ZERO, r.ONE_MINUS_SRC_ALPHA], !(r instanceof x.get().getWebGLRenderingContext()))
+    e.min = [r.ONE, r.ONE, r.ONE, r.ONE, r.MIN, r.MIN], e.max = [r.ONE, r.ONE, r.ONE, r.ONE, r.MAX, r.MAX];
+  else {
+    const s = r.getExtension("EXT_blend_minmax");
+    s && (e.min = [r.ONE, r.ONE, r.ONE, r.ONE, s.MIN_EXT, s.MIN_EXT], e.max = [r.ONE, r.ONE, r.ONE, r.ONE, s.MAX_EXT, s.MAX_EXT]);
+  }
+  return e;
+}
+const Xe = 0, Ve = 1, We = 2, ke = 3, Ke = 4, je = 5, te = class I {
+  constructor(e) {
+    this._invertFrontFace = !1, this.gl = null, this.stateId = 0, this.polygonOffset = 0, this.blendMode = "none", this._blendEq = !1, this.map = [], this.map[Xe] = this.setBlend, this.map[Ve] = this.setOffset, this.map[We] = this.setCullFace, this.map[ke] = this.setDepthTest, this.map[Ke] = this.setFrontFace, this.map[je] = this.setDepthMask, this.checks = [], this.defaultState = U.for2d(), e.renderTarget.onRenderTargetChange.add(this);
+  }
+  onRenderTargetChange(e) {
+    this._invertFrontFace = !e.isRoot, this._cullFace ? this.setFrontFace(this._frontFace) : this._frontFaceDirty = !0;
+  }
+  contextChange(e) {
+    this.gl = e, this.blendModesMap = He(e), this.resetState();
+  }
+  /**
+   * Sets the current state
+   * @param {*} state - The state to set.
+   */
+  set(e) {
+    if (e || (e = this.defaultState), this.stateId !== e.data) {
+      let t = this.stateId ^ e.data, s = 0;
+      for (; t; )
+        t & 1 && this.map[s].call(this, !!(e.data & 1 << s)), t >>= 1, s++;
+      this.stateId = e.data;
+    }
+    for (let t = 0; t < this.checks.length; t++)
+      this.checks[t](this, e);
+  }
+  /**
+   * Sets the state, when previous state is unknown.
+   * @param {*} state - The state to set
+   */
+  forceState(e) {
+    e || (e = this.defaultState);
+    for (let t = 0; t < this.map.length; t++)
+      this.map[t].call(this, !!(e.data & 1 << t));
+    for (let t = 0; t < this.checks.length; t++)
+      this.checks[t](this, e);
+    this.stateId = e.data;
+  }
+  /**
+   * Sets whether to enable or disable blending.
+   * @param value - Turn on or off WebGl blending.
+   */
+  setBlend(e) {
+    this._updateCheck(I._checkBlendMode, e), this.gl[e ? "enable" : "disable"](this.gl.BLEND);
+  }
+  /**
+   * Sets whether to enable or disable polygon offset fill.
+   * @param value - Turn on or off webgl polygon offset testing.
+   */
+  setOffset(e) {
+    this._updateCheck(I._checkPolygonOffset, e), this.gl[e ? "enable" : "disable"](this.gl.POLYGON_OFFSET_FILL);
+  }
+  /**
+   * Sets whether to enable or disable depth test.
+   * @param value - Turn on or off webgl depth testing.
+   */
+  setDepthTest(e) {
+    this.gl[e ? "enable" : "disable"](this.gl.DEPTH_TEST);
+  }
+  /**
+   * Sets whether to enable or disable depth mask.
+   * @param value - Turn on or off webgl depth mask.
+   */
+  setDepthMask(e) {
+    this.gl.depthMask(e);
+  }
+  /**
+   * Sets whether to enable or disable cull face.
+   * @param {boolean} value - Turn on or off webgl cull face.
+   */
+  setCullFace(e) {
+    this._cullFace = e, this.gl[e ? "enable" : "disable"](this.gl.CULL_FACE), this._cullFace && this._frontFaceDirty && this.setFrontFace(this._frontFace);
+  }
+  /**
+   * Sets the gl front face.
+   * @param {boolean} value - true is clockwise and false is counter-clockwise
+   */
+  setFrontFace(e) {
+    this._frontFace = e, this._frontFaceDirty = !1;
+    const t = this._invertFrontFace ? !e : e;
+    this._glFrontFace !== t && (this._glFrontFace = t, this.gl.frontFace(this.gl[t ? "CW" : "CCW"]));
+  }
+  /**
+   * Sets the blend mode.
+   * @param {number} value - The blend mode to set to.
+   */
+  setBlendMode(e) {
+    if (this.blendModesMap[e] || (e = "normal"), e === this.blendMode)
+      return;
+    this.blendMode = e;
+    const t = this.blendModesMap[e], s = this.gl;
+    t.length === 2 ? s.blendFunc(t[0], t[1]) : s.blendFuncSeparate(t[0], t[1], t[2], t[3]), t.length === 6 ? (this._blendEq = !0, s.blendEquationSeparate(t[4], t[5])) : this._blendEq && (this._blendEq = !1, s.blendEquationSeparate(s.FUNC_ADD, s.FUNC_ADD));
+  }
+  /**
+   * Sets the polygon offset.
+   * @param {number} value - the polygon offset
+   * @param {number} scale - the polygon offset scale
+   */
+  setPolygonOffset(e, t) {
+    this.gl.polygonOffset(e, t);
+  }
+  /** Resets all the logic and disables the VAOs. */
+  resetState() {
+    this._glFrontFace = !1, this._frontFace = !1, this._cullFace = !1, this._frontFaceDirty = !1, this._invertFrontFace = !1, this.gl.frontFace(this.gl.CCW), this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, !1), this.forceState(this.defaultState), this._blendEq = !0, this.blendMode = "", this.setBlendMode("normal");
+  }
+  /**
+   * Checks to see which updates should be checked based on which settings have been activated.
+   *
+   * For example, if blend is enabled then we should check the blend modes each time the state is changed
+   * or if polygon fill is activated then we need to check if the polygon offset changes.
+   * The idea is that we only check what we have too.
+   * @param func - the checking function to add or remove
+   * @param value - should the check function be added or removed.
+   */
+  _updateCheck(e, t) {
+    const s = this.checks.indexOf(e);
+    t && s === -1 ? this.checks.push(e) : !t && s !== -1 && this.checks.splice(s, 1);
+  }
+  /**
+   * A private little wrapper function that we call to check the blend mode.
+   * @param system - the System to perform the state check on
+   * @param state - the state that the blendMode will pulled from
+   */
+  static _checkBlendMode(e, t) {
+    e.setBlendMode(t.blendMode);
+  }
+  /**
+   * A private little wrapper function that we call to check the polygon offset.
+   * @param system - the System to perform the state check on
+   * @param state - the state that the blendMode will pulled from
+   */
+  static _checkPolygonOffset(e, t) {
+    e.setPolygonOffset(1, t.polygonOffset);
+  }
+  /** @ignore */
+  destroy() {
+    this.gl = null, this.checks.length = 0;
+  }
+};
+te.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "state"
+};
+let Ye = te;
+class ze {
+  constructor(e) {
+    this.target = M.TEXTURE_2D, this._layerInitMask = 0, this.texture = e, this.width = -1, this.height = -1, this.type = d.UNSIGNED_BYTE, this.internalFormat = G.RGBA, this.format = G.RGBA, this.samplerType = 0;
+  }
+  destroy() {
+  }
+}
+const qe = {
+  id: "buffer",
+  upload(r, e, t, s, n, i = !1) {
+    const a = n || e.target;
+    !i && e.width === r.width && e.height === r.height ? t.texSubImage2D(
+      a,
+      0,
+      0,
+      0,
+      r.width,
+      r.height,
+      e.format,
+      e.type,
+      r.resource
+    ) : t.texImage2D(
+      a,
+      0,
+      e.internalFormat,
+      r.width,
+      r.height,
+      0,
+      e.format,
+      e.type,
+      r.resource
+    ), e.width = r.width, e.height = r.height;
+  }
+}, Ze = {
+  "bc1-rgba-unorm": !0,
+  "bc1-rgba-unorm-srgb": !0,
+  "bc2-rgba-unorm": !0,
+  "bc2-rgba-unorm-srgb": !0,
+  "bc3-rgba-unorm": !0,
+  "bc3-rgba-unorm-srgb": !0,
+  "bc4-r-unorm": !0,
+  "bc4-r-snorm": !0,
+  "bc5-rg-unorm": !0,
+  "bc5-rg-snorm": !0,
+  "bc6h-rgb-ufloat": !0,
+  "bc6h-rgb-float": !0,
+  "bc7-rgba-unorm": !0,
+  "bc7-rgba-unorm-srgb": !0,
+  // ETC2 compressed formats usable if "texture-compression-etc2" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  "etc2-rgb8unorm": !0,
+  "etc2-rgb8unorm-srgb": !0,
+  "etc2-rgb8a1unorm": !0,
+  "etc2-rgb8a1unorm-srgb": !0,
+  "etc2-rgba8unorm": !0,
+  "etc2-rgba8unorm-srgb": !0,
+  "eac-r11unorm": !0,
+  "eac-r11snorm": !0,
+  "eac-rg11unorm": !0,
+  "eac-rg11snorm": !0,
+  // ASTC compressed formats usable if "texture-compression-astc" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  "astc-4x4-unorm": !0,
+  "astc-4x4-unorm-srgb": !0,
+  "astc-5x4-unorm": !0,
+  "astc-5x4-unorm-srgb": !0,
+  "astc-5x5-unorm": !0,
+  "astc-5x5-unorm-srgb": !0,
+  "astc-6x5-unorm": !0,
+  "astc-6x5-unorm-srgb": !0,
+  "astc-6x6-unorm": !0,
+  "astc-6x6-unorm-srgb": !0,
+  "astc-8x5-unorm": !0,
+  "astc-8x5-unorm-srgb": !0,
+  "astc-8x6-unorm": !0,
+  "astc-8x6-unorm-srgb": !0,
+  "astc-8x8-unorm": !0,
+  "astc-8x8-unorm-srgb": !0,
+  "astc-10x5-unorm": !0,
+  "astc-10x5-unorm-srgb": !0,
+  "astc-10x6-unorm": !0,
+  "astc-10x6-unorm-srgb": !0,
+  "astc-10x8-unorm": !0,
+  "astc-10x8-unorm-srgb": !0,
+  "astc-10x10-unorm": !0,
+  "astc-10x10-unorm-srgb": !0,
+  "astc-12x10-unorm": !0,
+  "astc-12x10-unorm-srgb": !0,
+  "astc-12x12-unorm": !0,
+  "astc-12x12-unorm-srgb": !0
+}, $e = {
+  id: "compressed",
+  upload(r, e, t, s, n, i) {
+    const a = n ?? e.target;
+    t.pixelStorei(t.UNPACK_ALIGNMENT, 4);
+    let o = r.pixelWidth, c = r.pixelHeight;
+    const _ = !!Ze[r.format];
+    for (let h = 0; h < r.resource.length; h++) {
+      const u = r.resource[h];
+      _ ? t.compressedTexImage2D(
+        a,
+        h,
+        e.internalFormat,
+        o,
+        c,
+        0,
+        u
+      ) : t.texImage2D(
+        a,
+        h,
+        e.internalFormat,
+        o,
+        c,
+        0,
+        e.format,
+        e.type,
+        u
+      ), o = Math.max(o >> 1, 1), c = Math.max(c >> 1, 1);
+    }
+  }
+}, w = ["right", "left", "top", "bottom", "front", "back"];
+function Qe(r) {
+  return {
+    id: "cube",
+    upload(e, t, s, n) {
+      const i = e.faces;
+      for (let a = 0; a < w.length; a++) {
+        const o = w[a], c = i[o];
+        (r[c.uploadMethodId] || r.image).upload(
+          c,
+          t,
+          s,
+          n,
+          // Use the face target for the current face. cube faces ids go up 1 so
+          // GL_TARGETS.TEXTURE_CUBE_MAP_POSITIVE_X + i addresses the i'th face target.
+          M.TEXTURE_CUBE_MAP_POSITIVE_X + a,
+          // Force allocation for the first upload of each face.
+          (t._layerInitMask & 1 << a) === 0
+        ), t._layerInitMask |= 1 << a;
+      }
+      t.width = e.pixelWidth, t.height = e.pixelHeight;
+    }
+  };
+}
+const re = {
+  id: "image",
+  upload(r, e, t, s, n, i = !1) {
+    const a = n || e.target, o = r.pixelWidth, c = r.pixelHeight, _ = r.resourceWidth, h = r.resourceHeight, u = s === 2, l = i || e.width !== o || e.height !== c, E = _ >= o && h >= c, b = r.resource;
+    (u ? Je : et)(
+      t,
+      a,
+      e,
+      o,
+      c,
+      _,
+      h,
+      b,
+      l,
+      E
+    ), e.width = o, e.height = c;
+  }
+};
+function Je(r, e, t, s, n, i, a, o, c, _) {
+  if (!_) {
+    c && r.texImage2D(
+      e,
+      0,
+      t.internalFormat,
+      s,
+      n,
+      0,
+      t.format,
+      t.type,
+      null
+    ), r.texSubImage2D(
+      e,
+      0,
+      0,
+      0,
+      i,
+      a,
+      t.format,
+      t.type,
+      o
+    );
+    return;
+  }
+  if (!c) {
+    r.texSubImage2D(
+      e,
+      0,
+      0,
+      0,
+      t.format,
+      t.type,
+      o
+    );
+    return;
+  }
+  r.texImage2D(
+    e,
+    0,
+    t.internalFormat,
+    s,
+    n,
+    0,
+    t.format,
+    t.type,
+    o
+  );
+}
+function et(r, e, t, s, n, i, a, o, c, _) {
+  if (!_) {
+    c && r.texImage2D(
+      e,
+      0,
+      t.internalFormat,
+      s,
+      n,
+      0,
+      t.format,
+      t.type,
+      null
+    ), r.texSubImage2D(
+      e,
+      0,
+      0,
+      0,
+      t.format,
+      t.type,
+      o
+    );
+    return;
+  }
+  if (!c) {
+    r.texSubImage2D(
+      e,
+      0,
+      0,
+      0,
+      t.format,
+      t.type,
+      o
+    );
+    return;
+  }
+  r.texImage2D(
+    e,
+    0,
+    t.internalFormat,
+    t.format,
+    t.type,
+    o
+  );
+}
+const tt = De(), rt = {
+  id: "video",
+  upload(r, e, t, s, n, i = tt) {
+    if (!r.isValid) {
+      const a = n ?? e.target;
+      t.texImage2D(
+        a,
+        0,
+        e.internalFormat,
+        1,
+        1,
+        0,
+        e.format,
+        e.type,
+        null
+      );
+      return;
+    }
+    re.upload(r, e, t, s, n, i);
+  }
+}, v = {
+  linear: 9729,
+  nearest: 9728
+}, st = {
+  linear: {
+    linear: 9987,
+    nearest: 9985
+  },
+  nearest: {
+    linear: 9986,
+    nearest: 9984
+  }
+}, N = {
+  "clamp-to-edge": 33071,
+  repeat: 10497,
+  "mirror-repeat": 33648
+}, nt = {
+  never: 512,
+  less: 513,
+  equal: 514,
+  "less-equal": 515,
+  greater: 516,
+  "not-equal": 517,
+  "greater-equal": 518,
+  always: 519
+};
+function H(r, e, t, s, n, i, a, o) {
+  const c = i;
+  if (!o || r.addressModeU !== "repeat" || r.addressModeV !== "repeat" || r.addressModeW !== "repeat") {
+    const _ = N[a ? "clamp-to-edge" : r.addressModeU], h = N[a ? "clamp-to-edge" : r.addressModeV], u = N[a ? "clamp-to-edge" : r.addressModeW];
+    e[n](c, e.TEXTURE_WRAP_S, _), e[n](c, e.TEXTURE_WRAP_T, h), e.TEXTURE_WRAP_R && e[n](c, e.TEXTURE_WRAP_R, u);
+  }
+  if ((!o || r.magFilter !== "linear") && e[n](c, e.TEXTURE_MAG_FILTER, v[r.magFilter]), t) {
+    if (!o || r.mipmapFilter !== "linear") {
+      const _ = st[r.minFilter][r.mipmapFilter];
+      e[n](c, e.TEXTURE_MIN_FILTER, _);
+    }
+  } else
+    e[n](c, e.TEXTURE_MIN_FILTER, v[r.minFilter]);
+  if (s && r.maxAnisotropy > 1) {
+    const _ = Math.min(r.maxAnisotropy, e.getParameter(s.MAX_TEXTURE_MAX_ANISOTROPY_EXT));
+    e[n](c, s.TEXTURE_MAX_ANISOTROPY_EXT, _);
+  }
+  r.compare && e[n](c, e.TEXTURE_COMPARE_FUNC, nt[r.compare]);
+}
+function it(r) {
+  return {
+    // 8-bit formats
+    r8unorm: r.RED,
+    r8snorm: r.RED,
+    r8uint: r.RED,
+    r8sint: r.RED,
+    // 16-bit formats
+    r16uint: r.RED,
+    r16sint: r.RED,
+    r16float: r.RED,
+    rg8unorm: r.RG,
+    rg8snorm: r.RG,
+    rg8uint: r.RG,
+    rg8sint: r.RG,
+    // 32-bit formats
+    r32uint: r.RED,
+    r32sint: r.RED,
+    r32float: r.RED,
+    rg16uint: r.RG,
+    rg16sint: r.RG,
+    rg16float: r.RG,
+    rgba8unorm: r.RGBA,
+    "rgba8unorm-srgb": r.RGBA,
+    // Packed 32-bit formats
+    rgba8snorm: r.RGBA,
+    rgba8uint: r.RGBA,
+    rgba8sint: r.RGBA,
+    bgra8unorm: r.RGBA,
+    "bgra8unorm-srgb": r.RGBA,
+    rgb9e5ufloat: r.RGB,
+    rgb10a2unorm: r.RGBA,
+    rg11b10ufloat: r.RGB,
+    // 64-bit formats
+    rg32uint: r.RG,
+    rg32sint: r.RG,
+    rg32float: r.RG,
+    rgba16uint: r.RGBA,
+    rgba16sint: r.RGBA,
+    rgba16float: r.RGBA,
+    // 128-bit formats
+    rgba32uint: r.RGBA,
+    rgba32sint: r.RGBA,
+    rgba32float: r.RGBA,
+    // Depth/stencil formats
+    stencil8: r.STENCIL_INDEX8,
+    depth16unorm: r.DEPTH_COMPONENT,
+    depth24plus: r.DEPTH_COMPONENT,
+    "depth24plus-stencil8": r.DEPTH_STENCIL,
+    depth32float: r.DEPTH_COMPONENT,
+    "depth32float-stencil8": r.DEPTH_STENCIL
+  };
+}
+function at(r, e) {
+  let t = {}, s = r.RGBA;
+  return r instanceof x.get().getWebGLRenderingContext() ? e.srgb && (t = {
+    "rgba8unorm-srgb": e.srgb.SRGB8_ALPHA8_EXT,
+    "bgra8unorm-srgb": e.srgb.SRGB8_ALPHA8_EXT
+  }) : (t = {
+    "rgba8unorm-srgb": r.SRGB8_ALPHA8,
+    "bgra8unorm-srgb": r.SRGB8_ALPHA8
+  }, s = r.RGBA8), {
+    // 8-bit formats
+    r8unorm: r.R8,
+    r8snorm: r.R8_SNORM,
+    r8uint: r.R8UI,
+    r8sint: r.R8I,
+    // 16-bit formats
+    r16uint: r.R16UI,
+    r16sint: r.R16I,
+    r16float: r.R16F,
+    rg8unorm: r.RG8,
+    rg8snorm: r.RG8_SNORM,
+    rg8uint: r.RG8UI,
+    rg8sint: r.RG8I,
+    // 32-bit formats
+    r32uint: r.R32UI,
+    r32sint: r.R32I,
+    r32float: r.R32F,
+    rg16uint: r.RG16UI,
+    rg16sint: r.RG16I,
+    rg16float: r.RG16F,
+    rgba8unorm: r.RGBA,
+    ...t,
+    // Packed 32-bit formats
+    rgba8snorm: r.RGBA8_SNORM,
+    rgba8uint: r.RGBA8UI,
+    rgba8sint: r.RGBA8I,
+    bgra8unorm: s,
+    rgb9e5ufloat: r.RGB9_E5,
+    rgb10a2unorm: r.RGB10_A2,
+    rg11b10ufloat: r.R11F_G11F_B10F,
+    // 64-bit formats
+    rg32uint: r.RG32UI,
+    rg32sint: r.RG32I,
+    rg32float: r.RG32F,
+    rgba16uint: r.RGBA16UI,
+    rgba16sint: r.RGBA16I,
+    rgba16float: r.RGBA16F,
+    // 128-bit formats
+    rgba32uint: r.RGBA32UI,
+    rgba32sint: r.RGBA32I,
+    rgba32float: r.RGBA32F,
+    // Depth/stencil formats
+    stencil8: r.STENCIL_INDEX8,
+    depth16unorm: r.DEPTH_COMPONENT16,
+    depth24plus: r.DEPTH_COMPONENT24,
+    "depth24plus-stencil8": r.DEPTH24_STENCIL8,
+    depth32float: r.DEPTH_COMPONENT32F,
+    "depth32float-stencil8": r.DEPTH32F_STENCIL8,
+    // Compressed formats
+    ...e.s3tc ? {
+      "bc1-rgba-unorm": e.s3tc.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+      "bc2-rgba-unorm": e.s3tc.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+      "bc3-rgba-unorm": e.s3tc.COMPRESSED_RGBA_S3TC_DXT5_EXT
+    } : {},
+    ...e.s3tc_sRGB ? {
+      "bc1-rgba-unorm-srgb": e.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+      "bc2-rgba-unorm-srgb": e.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+      "bc3-rgba-unorm-srgb": e.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
+    } : {},
+    ...e.rgtc ? {
+      "bc4-r-unorm": e.rgtc.COMPRESSED_RED_RGTC1_EXT,
+      "bc4-r-snorm": e.rgtc.COMPRESSED_SIGNED_RED_RGTC1_EXT,
+      "bc5-rg-unorm": e.rgtc.COMPRESSED_RED_GREEN_RGTC2_EXT,
+      "bc5-rg-snorm": e.rgtc.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT
+    } : {},
+    ...e.bptc ? {
+      "bc6h-rgb-float": e.bptc.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT,
+      "bc6h-rgb-ufloat": e.bptc.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT,
+      "bc7-rgba-unorm": e.bptc.COMPRESSED_RGBA_BPTC_UNORM_EXT,
+      "bc7-rgba-unorm-srgb": e.bptc.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT
+    } : {},
+    ...e.etc ? {
+      "etc2-rgb8unorm": e.etc.COMPRESSED_RGB8_ETC2,
+      "etc2-rgb8unorm-srgb": e.etc.COMPRESSED_SRGB8_ETC2,
+      "etc2-rgb8a1unorm": e.etc.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+      "etc2-rgb8a1unorm-srgb": e.etc.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+      "etc2-rgba8unorm": e.etc.COMPRESSED_RGBA8_ETC2_EAC,
+      "etc2-rgba8unorm-srgb": e.etc.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+      "eac-r11unorm": e.etc.COMPRESSED_R11_EAC,
+      // 'eac-r11snorm'
+      "eac-rg11unorm": e.etc.COMPRESSED_SIGNED_RG11_EAC
+      // 'eac-rg11snorm'
+    } : {},
+    ...e.astc ? {
+      "astc-4x4-unorm": e.astc.COMPRESSED_RGBA_ASTC_4x4_KHR,
+      "astc-4x4-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+      "astc-5x4-unorm": e.astc.COMPRESSED_RGBA_ASTC_5x4_KHR,
+      "astc-5x4-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
+      "astc-5x5-unorm": e.astc.COMPRESSED_RGBA_ASTC_5x5_KHR,
+      "astc-5x5-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+      "astc-6x5-unorm": e.astc.COMPRESSED_RGBA_ASTC_6x5_KHR,
+      "astc-6x5-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+      "astc-6x6-unorm": e.astc.COMPRESSED_RGBA_ASTC_6x6_KHR,
+      "astc-6x6-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+      "astc-8x5-unorm": e.astc.COMPRESSED_RGBA_ASTC_8x5_KHR,
+      "astc-8x5-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+      "astc-8x6-unorm": e.astc.COMPRESSED_RGBA_ASTC_8x6_KHR,
+      "astc-8x6-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+      "astc-8x8-unorm": e.astc.COMPRESSED_RGBA_ASTC_8x8_KHR,
+      "astc-8x8-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+      "astc-10x5-unorm": e.astc.COMPRESSED_RGBA_ASTC_10x5_KHR,
+      "astc-10x5-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+      "astc-10x6-unorm": e.astc.COMPRESSED_RGBA_ASTC_10x6_KHR,
+      "astc-10x6-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+      "astc-10x8-unorm": e.astc.COMPRESSED_RGBA_ASTC_10x8_KHR,
+      "astc-10x8-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+      "astc-10x10-unorm": e.astc.COMPRESSED_RGBA_ASTC_10x10_KHR,
+      "astc-10x10-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+      "astc-12x10-unorm": e.astc.COMPRESSED_RGBA_ASTC_12x10_KHR,
+      "astc-12x10-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+      "astc-12x12-unorm": e.astc.COMPRESSED_RGBA_ASTC_12x12_KHR,
+      "astc-12x12-unorm-srgb": e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
+    } : {}
+  };
+}
+function ot(r) {
+  return {
+    // 8-bit formats
+    r8unorm: r.UNSIGNED_BYTE,
+    r8snorm: r.BYTE,
+    r8uint: r.UNSIGNED_BYTE,
+    r8sint: r.BYTE,
+    // 16-bit formats
+    r16uint: r.UNSIGNED_SHORT,
+    r16sint: r.SHORT,
+    r16float: r.HALF_FLOAT,
+    rg8unorm: r.UNSIGNED_BYTE,
+    rg8snorm: r.BYTE,
+    rg8uint: r.UNSIGNED_BYTE,
+    rg8sint: r.BYTE,
+    // 32-bit formats
+    r32uint: r.UNSIGNED_INT,
+    r32sint: r.INT,
+    r32float: r.FLOAT,
+    rg16uint: r.UNSIGNED_SHORT,
+    rg16sint: r.SHORT,
+    rg16float: r.HALF_FLOAT,
+    rgba8unorm: r.UNSIGNED_BYTE,
+    "rgba8unorm-srgb": r.UNSIGNED_BYTE,
+    // Packed 32-bit formats
+    rgba8snorm: r.BYTE,
+    rgba8uint: r.UNSIGNED_BYTE,
+    rgba8sint: r.BYTE,
+    bgra8unorm: r.UNSIGNED_BYTE,
+    "bgra8unorm-srgb": r.UNSIGNED_BYTE,
+    rgb9e5ufloat: r.UNSIGNED_INT_5_9_9_9_REV,
+    rgb10a2unorm: r.UNSIGNED_INT_2_10_10_10_REV,
+    rg11b10ufloat: r.UNSIGNED_INT_10F_11F_11F_REV,
+    // 64-bit formats
+    rg32uint: r.UNSIGNED_INT,
+    rg32sint: r.INT,
+    rg32float: r.FLOAT,
+    rgba16uint: r.UNSIGNED_SHORT,
+    rgba16sint: r.SHORT,
+    rgba16float: r.HALF_FLOAT,
+    // 128-bit formats
+    rgba32uint: r.UNSIGNED_INT,
+    rgba32sint: r.INT,
+    rgba32float: r.FLOAT,
+    // Depth/stencil formats
+    stencil8: r.UNSIGNED_BYTE,
+    depth16unorm: r.UNSIGNED_SHORT,
+    depth24plus: r.UNSIGNED_INT,
+    "depth24plus-stencil8": r.UNSIGNED_INT_24_8,
+    depth32float: r.FLOAT,
+    "depth32float-stencil8": r.FLOAT_32_UNSIGNED_INT_24_8_REV
+  };
+}
+function _t(r) {
+  return {
+    "2d": r.TEXTURE_2D,
+    cube: r.TEXTURE_CUBE_MAP,
+    "1d": null,
+    // WebGL2 only
+    "3d": (r == null ? void 0 : r.TEXTURE_3D) || null,
+    "2d-array": (r == null ? void 0 : r.TEXTURE_2D_ARRAY) || null,
+    "cube-array": (r == null ? void 0 : r.TEXTURE_CUBE_MAP_ARRAY) || null
+  };
+}
+const ct = 4;
+class se {
+  constructor(e) {
+    this._glSamplers = /* @__PURE__ */ Object.create(null), this._boundTextures = [], this._activeTextureLocation = -1, this._boundSamplers = /* @__PURE__ */ Object.create(null), this._premultiplyAlpha = !1, this._useSeparateSamplers = !1, this._renderer = e, this._managedTextures = new D({
+      renderer: e,
+      type: "resource",
+      onUnload: this.onSourceUnload.bind(this),
+      name: "glTexture"
+    });
+    const t = {
+      image: re,
+      buffer: qe,
+      video: rt,
+      compressed: $e
+    };
+    this._uploads = {
+      ...t,
+      cube: Qe(t)
+    };
+  }
+  /**
+   * @deprecated since 8.15.0
+   */
+  get managedTextures() {
+    return Object.values(this._managedTextures.items);
+  }
+  contextChange(e) {
+    this._gl = e, this._mapFormatToInternalFormat || (this._mapFormatToInternalFormat = at(e, this._renderer.context.extensions), this._mapFormatToType = ot(e), this._mapFormatToFormat = it(e), this._mapViewDimensionToGlTarget = _t(e)), this._managedTextures.removeAll(!0), this._glSamplers = /* @__PURE__ */ Object.create(null), this._boundSamplers = /* @__PURE__ */ Object.create(null), this._premultiplyAlpha = !1;
+    for (let t = 0; t < 16; t++)
+      this.bind(R.EMPTY, t);
+  }
+  /**
+   * Initializes a texture source, if it has already been initialized nothing will happen.
+   * @param source - The texture source to initialize.
+   * @returns The initialized texture source.
+   */
+  initSource(e) {
+    this.bind(e);
+  }
+  bind(e, t = 0) {
+    const s = e.source;
+    e ? (this.bindSource(s, t), this._useSeparateSamplers && this._bindSampler(s.style, t)) : (this.bindSource(null, t), this._useSeparateSamplers && this._bindSampler(null, t));
+  }
+  bindSource(e, t = 0) {
+    const s = this._gl;
+    if (e._gcLastUsed = this._renderer.gc.now, this._boundTextures[t] !== e) {
+      this._boundTextures[t] = e, this._activateLocation(t), e || (e = R.EMPTY.source);
+      const n = this.getGlSource(e);
+      s.bindTexture(n.target, n.texture);
+    }
+  }
+  _bindSampler(e, t = 0) {
+    const s = this._gl;
+    if (!e) {
+      this._boundSamplers[t] = null, s.bindSampler(t, null);
+      return;
+    }
+    const n = this._getGlSampler(e);
+    this._boundSamplers[t] !== n && (this._boundSamplers[t] = n, s.bindSampler(t, n));
+  }
+  unbind(e) {
+    const t = e.source, s = this._boundTextures, n = this._gl;
+    for (let i = 0; i < s.length; i++)
+      if (s[i] === t) {
+        this._activateLocation(i);
+        const a = this.getGlSource(t);
+        n.bindTexture(a.target, null), s[i] = null;
+      }
+  }
+  _activateLocation(e) {
+    this._activeTextureLocation !== e && (this._activeTextureLocation = e, this._gl.activeTexture(this._gl.TEXTURE0 + e));
+  }
+  _initSource(e) {
+    const t = this._gl, s = new ze(t.createTexture());
+    if (s.type = this._mapFormatToType[e.format], s.internalFormat = this._mapFormatToInternalFormat[e.format], s.format = this._mapFormatToFormat[e.format], s.target = this._mapViewDimensionToGlTarget[e.viewDimension], s.target === null)
+      throw new Error(`Unsupported view dimension: ${e.viewDimension} with this webgl version: ${this._renderer.context.webGLVersion}`);
+    if (e.uploadMethodId === "cube" && (s.target = t.TEXTURE_CUBE_MAP), e.autoGenerateMipmaps && (this._renderer.context.supports.nonPowOf2mipmaps || e.isPowerOfTwo)) {
+      const i = Math.max(e.width, e.height);
+      e.mipLevelCount = Math.floor(Math.log2(i)) + 1;
+    }
+    return e._gpuData[this._renderer.uid] = s, this._managedTextures.add(e) && (e.on("update", this.onSourceUpdate, this), e.on("resize", this.onSourceUpdate, this), e.on("styleChange", this.onStyleChange, this), e.on("updateMipmaps", this.onUpdateMipmaps, this)), this.onSourceUpdate(e), this.updateStyle(e, !1), s;
+  }
+  onStyleChange(e) {
+    this.updateStyle(e, !1);
+  }
+  updateStyle(e, t) {
+    const s = this._gl, n = this.getGlSource(e);
+    s.bindTexture(n.target, n.texture), this._boundTextures[this._activeTextureLocation] = e, H(
+      e.style,
+      s,
+      e.mipLevelCount > 1,
+      this._renderer.context.extensions.anisotropicFiltering,
+      "texParameteri",
+      n.target,
+      // will force a clamp to edge if the texture is not a power of two
+      !this._renderer.context.supports.nonPowOf2wrapping && !e.isPowerOfTwo,
+      t
+    );
+  }
+  onSourceUnload(e, t = !1) {
+    const s = e._gpuData[this._renderer.uid];
+    s && (t || (this.unbind(e), this._gl.deleteTexture(s.texture)), e.off("update", this.onSourceUpdate, this), e.off("resize", this.onSourceUpdate, this), e.off("styleChange", this.onStyleChange, this), e.off("updateMipmaps", this.onUpdateMipmaps, this));
+  }
+  onSourceUpdate(e) {
+    const t = this._gl, s = this.getGlSource(e);
+    t.bindTexture(s.target, s.texture), this._boundTextures[this._activeTextureLocation] = e;
+    const n = e.alphaMode === "premultiply-alpha-on-upload";
+    if (this._premultiplyAlpha !== n && (this._premultiplyAlpha = n, t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, n)), this._uploads[e.uploadMethodId])
+      this._uploads[e.uploadMethodId].upload(e, s, t, this._renderer.context.webGLVersion);
+    else if (s.target === t.TEXTURE_2D)
+      this._initEmptyTexture2D(s, e);
+    else if (s.target === t.TEXTURE_2D_ARRAY)
+      this._initEmptyTexture2DArray(s, e);
+    else if (s.target === t.TEXTURE_CUBE_MAP)
+      this._initEmptyTextureCube(s, e);
+    else
+      throw new Error("[GlTextureSystem] Unsupported texture target for empty allocation.");
+    this._applyMipRange(s, e), e.autoGenerateMipmaps && e.mipLevelCount > 1 && this.onUpdateMipmaps(e, !1);
+  }
+  onUpdateMipmaps(e, t = !0) {
+    t && this.bindSource(e, 0);
+    const s = this.getGlSource(e);
+    this._gl.generateMipmap(s.target);
+  }
+  _initEmptyTexture2D(e, t) {
+    const s = this._gl;
+    s.texImage2D(
+      s.TEXTURE_2D,
+      0,
+      e.internalFormat,
+      t.pixelWidth,
+      t.pixelHeight,
+      0,
+      e.format,
+      e.type,
+      null
+    );
+    let n = Math.max(t.pixelWidth >> 1, 1), i = Math.max(t.pixelHeight >> 1, 1);
+    for (let a = 1; a < t.mipLevelCount; a++)
+      s.texImage2D(
+        s.TEXTURE_2D,
+        a,
+        e.internalFormat,
+        n,
+        i,
+        0,
+        e.format,
+        e.type,
+        null
+      ), n = Math.max(n >> 1, 1), i = Math.max(i >> 1, 1);
+  }
+  _initEmptyTexture2DArray(e, t) {
+    if (this._renderer.context.webGLVersion !== 2)
+      throw new Error("[GlTextureSystem] TEXTURE_2D_ARRAY requires WebGL2.");
+    const s = this._gl, n = Math.max(t.arrayLayerCount | 0, 1);
+    s.texImage3D(
+      s.TEXTURE_2D_ARRAY,
+      0,
+      e.internalFormat,
+      t.pixelWidth,
+      t.pixelHeight,
+      n,
+      0,
+      e.format,
+      e.type,
+      null
+    );
+    let i = Math.max(t.pixelWidth >> 1, 1), a = Math.max(t.pixelHeight >> 1, 1);
+    for (let o = 1; o < t.mipLevelCount; o++)
+      s.texImage3D(
+        s.TEXTURE_2D_ARRAY,
+        o,
+        e.internalFormat,
+        i,
+        a,
+        n,
+        0,
+        e.format,
+        e.type,
+        null
+      ), i = Math.max(i >> 1, 1), a = Math.max(a >> 1, 1);
+  }
+  _initEmptyTextureCube(e, t) {
+    const s = this._gl, n = 6;
+    for (let o = 0; o < n; o++)
+      s.texImage2D(
+        s.TEXTURE_CUBE_MAP_POSITIVE_X + o,
+        0,
+        e.internalFormat,
+        t.pixelWidth,
+        t.pixelHeight,
+        0,
+        e.format,
+        e.type,
+        null
+      );
+    let i = Math.max(t.pixelWidth >> 1, 1), a = Math.max(t.pixelHeight >> 1, 1);
+    for (let o = 1; o < t.mipLevelCount; o++) {
+      for (let c = 0; c < n; c++)
+        s.texImage2D(
+          s.TEXTURE_CUBE_MAP_POSITIVE_X + c,
+          o,
+          e.internalFormat,
+          i,
+          a,
+          0,
+          e.format,
+          e.type,
+          null
+        );
+      i = Math.max(i >> 1, 1), a = Math.max(a >> 1, 1);
+    }
+  }
+  /**
+   * Applies a mip range to the currently-bound texture so WebGL2 considers the texture "mipmap complete"
+   * for the declared `mipLevelCount` (especially important for partial mip chains rendered via FBO).
+   * @param glTexture - The GL texture wrapper.
+   * @param source - The texture source describing mipLevelCount.
+   */
+  _applyMipRange(e, t) {
+    if (this._renderer.context.webGLVersion !== 2) return;
+    const s = this._gl, n = Math.max((t.mipLevelCount | 0) - 1, 0);
+    s.texParameteri(e.target, s.TEXTURE_BASE_LEVEL, 0), s.texParameteri(e.target, s.TEXTURE_MAX_LEVEL, n);
+  }
+  _initSampler(e) {
+    const t = this._gl, s = this._gl.createSampler();
+    return this._glSamplers[e._resourceId] = s, H(
+      e,
+      t,
+      this._boundTextures[this._activeTextureLocation].mipLevelCount > 1,
+      this._renderer.context.extensions.anisotropicFiltering,
+      "samplerParameteri",
+      s,
+      !1,
+      !0
+    ), this._glSamplers[e._resourceId];
+  }
+  _getGlSampler(e) {
+    return this._glSamplers[e._resourceId] || this._initSampler(e);
+  }
+  getGlSource(e) {
+    return e._gcLastUsed = this._renderer.gc.now, e._gpuData[this._renderer.uid] || this._initSource(e);
+  }
+  generateCanvas(e) {
+    const { pixels: t, width: s, height: n } = this.getPixels(e), i = x.get().createCanvas();
+    i.width = s, i.height = n;
+    const a = i.getContext("2d");
+    if (a) {
+      const o = a.createImageData(s, n);
+      o.data.set(t), a.putImageData(o, 0, 0);
+    }
+    return i;
+  }
+  getPixels(e) {
+    const t = e.source.resolution, s = e.frame, n = Math.max(Math.round(s.width * t), 1), i = Math.max(Math.round(s.height * t), 1), a = new Uint8Array(ct * n * i), o = this._renderer, c = o.renderTarget.getRenderTarget(e), _ = o.renderTarget.getGpuRenderTarget(c), h = o.gl;
+    return h.bindFramebuffer(h.FRAMEBUFFER, _.resolveTargetFramebuffer), h.readPixels(
+      Math.round(s.x * t),
+      Math.round(s.y * t),
+      n,
+      i,
+      h.RGBA,
+      h.UNSIGNED_BYTE,
+      a
+    ), { pixels: new Uint8ClampedArray(a.buffer), width: n, height: i };
+  }
+  destroy() {
+    this._managedTextures.destroy(), this._glSamplers = null, this._boundTextures = null, this._boundSamplers = null, this._mapFormatToInternalFormat = null, this._mapFormatToType = null, this._mapFormatToFormat = null, this._uploads = null, this._renderer = null;
+  }
+  resetState() {
+    this._activeTextureLocation = -1, this._boundTextures.fill(R.EMPTY.source), this._boundSamplers = /* @__PURE__ */ Object.create(null);
+    const e = this._gl;
+    this._premultiplyAlpha = !1, e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this._premultiplyAlpha);
+  }
+}
+se.extension = {
+  type: [
+    f.WebGLSystem
+  ],
+  name: "texture"
+};
+class ne {
+  contextChange(e) {
+    const t = new le({
+      uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+      uTransformMatrix: { value: new X(), type: "mat3x3<f32>" },
+      uRound: { value: 0, type: "f32" }
+    }), s = e.limits.maxBatchableTextures, n = V({
+      name: "graphics",
+      bits: [
+        xe,
+        Te(s),
+        k,
+        W
+      ]
+    });
+    this.shader = new y({
+      glProgram: n,
+      resources: {
+        localUniforms: t,
+        batchSamplers: Se(s)
+      }
+    });
+  }
+  execute(e, t) {
+    const s = t.context, n = s.customShader || this.shader, i = e.renderer, a = i.graphicsContext, {
+      batcher: o,
+      instructions: c
+    } = a.getContextRenderData(s);
+    n.groups[0] = i.globalUniforms.bindGroup, i.state.set(e.state), i.shader.bind(n), i.geometry.bind(o.geometry, n.glProgram);
+    const _ = c.instructions;
+    for (let h = 0; h < c.instructionSize; h++) {
+      const u = _[h];
+      if (u.size) {
+        for (let l = 0; l < u.textures.count; l++)
+          i.texture.bind(u.textures.textures[l], l);
+        i.geometry.draw(u.topology, u.size, u.start);
+      }
+    }
+  }
+  destroy() {
+    this.shader.destroy(!0), this.shader = null;
+  }
+}
+ne.extension = {
+  type: [
+    f.WebGLPipesAdaptor
+  ],
+  name: "graphics"
+};
+class ie {
+  init() {
+    const e = V({
+      name: "mesh",
+      bits: [
+        k,
+        Ne,
+        W
+      ]
+    });
+    this._shader = new y({
+      glProgram: e,
+      resources: {
+        uTexture: R.EMPTY.source,
+        textureUniforms: {
+          uTextureMatrix: { type: "mat3x3<f32>", value: new X() }
+        }
+      }
+    });
+  }
+  execute(e, t) {
+    const s = e.renderer;
+    let n = t._shader;
+    if (n) {
+      if (!n.glProgram) {
+        p("Mesh shader has no glProgram", t.shader);
+        return;
+      }
+    } else {
+      n = this._shader;
+      const i = t.texture, a = i.source;
+      n.resources.uTexture = a, n.resources.uSampler = a.style, n.resources.textureUniforms.uniforms.uTextureMatrix = i.textureMatrix.mapCoord;
+    }
+    n.groups[100] = s.globalUniforms.bindGroup, n.groups[101] = e.localUniformsBindGroup, s.encoder.draw({
+      geometry: t._geometry,
+      shader: n,
+      state: t.state
+    });
+  }
+  destroy() {
+    this._shader.destroy(!0), this._shader = null;
+  }
+}
+ie.extension = {
+  type: [
+    f.WebGLPipesAdaptor
+  ],
+  name: "mesh"
+};
+const ht = [
+  ...ge,
+  Ee,
+  Pe,
+  ye,
+  Q,
+  j,
+  se,
+  ee,
+  z,
+  me,
+  be,
+  $,
+  Ye,
+  J,
+  Z
+], ut = [...Be], dt = [K, ie, ne], ae = [], oe = [], _e = [];
+g.handleByNamedList(f.WebGLSystem, ae);
+g.handleByNamedList(f.WebGLPipes, oe);
+g.handleByNamedList(f.WebGLPipesAdaptor, _e);
+g.add(...ht, ...ut, ...dt);
+class bt extends fe {
+  constructor() {
+    const e = {
+      name: "webgl",
+      type: Ie.WEBGL,
+      systems: ae,
+      renderPipes: oe,
+      renderPipeAdaptors: _e
+    };
+    super(e);
+  }
+}
+export {
+  bt as WebGLRenderer
+};
+//# sourceMappingURL=WebGLRenderer-BtNMOOvs.js.map