holostaff-widget 3.0.2 → 3.0.3

package/dist/{WebGPURenderer-SF1OSYpo.js → WebGPURenderer-89fMKfXn.js}

@@ -1,9 +1,9 @@
-import { D as x, n as M, G as de, c as p, a as he, w as U, d as y, f as le, g as pe, M as A, T as R, A as fe, e as S } from "./index-qJyFW51-.js";
-import { g as D } from "./getTextureBatchBindGroup-BPB_9pp9.js";
-import { G as k, f as ge, S as v, R as me, c as z, a as _e, r as F, g as be, b as ye, d as xe } from "./RenderTargetSystem-CahYKOD4.js";
-import { c as Ge, u as Pe, U as Be, B as Se, G as Te, e as ve, l as Ce, a as Ue, t as we } from "./BufferResource-6mO-PO_c.js";
-import { S as O, b as T, a as Me, B as I, c as E, U as W, d as H, R as Re } from "./Geometry-B-K9I6MO.js";
-class Ee {
+import { D as x, n as w, G as ue, E as l, u as ce, B as S, f as de, h as he, c as M, w as v, i as y, j as pe, k as le, d as L, M as A, T as R, A as fe, e as B, l as ge } from "./index-BpOQ7Z5z.js";
+import { g as D } from "./getTextureBatchBindGroup-CMmHwizJ.js";
+import { G as k, f as me, S as T, R as _e, c as F, a as be, r as O, g as ye, b as xe, d as Ge } from "./RenderTargetSystem-Bl4mRBf3.js";
+import { G as Pe, e as Be, l as Se, a as Te, t as Ce } from "./GpuStencilModesToPixi-Cc8Nerk4.js";
+import { S as I, B as H, a as W, R as ve } from "./Filter-GqToX76B.js";
+class Ue {
   constructor(e) {
     this._canvasPool = /* @__PURE__ */ Object.create(null), this.canvasOptions = e || {}, this.enableFullScreen = !1;
   }
@@ -26,40 +26,40 @@ class Ee {
    * @returns The new render texture.
    */
   getOptimalCanvasAndContext(e, t, r = 1) {
-    e = Math.ceil(e * r - 1e-6), t = Math.ceil(t * r - 1e-6), e = M(e), t = M(t);
+    e = Math.ceil(e * r - 1e-6), t = Math.ceil(t * r - 1e-6), e = w(e), t = w(t);
     const s = (e << 17) + (t << 1);
     this._canvasPool[s] || (this._canvasPool[s] = []);
-    let i = this._canvasPool[s].pop();
-    return i || (i = this._createCanvasAndContext(e, t)), i;
+    let n = this._canvasPool[s].pop();
+    return n || (n = this._createCanvasAndContext(e, t)), n;
   }
   /**
    * Place a render texture back into the pool.
    * @param canvasAndContext
    */
   returnCanvasAndContext(e) {
-    const t = e.canvas, { width: r, height: s } = t, i = (r << 17) + (s << 1);
-    e.context.resetTransform(), e.context.clearRect(0, 0, r, s), this._canvasPool[i].push(e);
+    const t = e.canvas, { width: r, height: s } = t, n = (r << 17) + (s << 1);
+    e.context.resetTransform(), e.context.clearRect(0, 0, r, s), this._canvasPool[n].push(e);
   }
   clear() {
     this._canvasPool = {};
   }
 }
-const C = new Ee();
-de.register(C);
-const P = O.for2d();
+const C = new Ue();
+ue.register(C);
+const P = I.for2d();
 class V {
   start(e, t, r) {
-    const s = e.renderer, i = s.encoder, n = r.gpuProgram;
-    this._shader = r, this._geometry = t, i.setGeometry(t, n), P.blendMode = "normal", s.pipeline.getPipeline(
+    const s = e.renderer, n = s.encoder, i = r.gpuProgram;
+    this._shader = r, this._geometry = t, n.setGeometry(t, i), P.blendMode = "normal", s.pipeline.getPipeline(
       t,
-      n,
+      i,
       P
     );
     const o = s.globalUniforms.bindGroup;
-    i.resetBindGroup(1), i.setBindGroup(0, o, n);
+    n.resetBindGroup(1), n.setBindGroup(0, o, i);
   }
   execute(e, t) {
-    const r = this._shader.gpuProgram, s = e.renderer, i = s.encoder;
+    const r = this._shader.gpuProgram, s = e.renderer, n = s.encoder;
     if (!t.bindGroup) {
       const u = t.textures;
       t.bindGroup = D(
@@ -69,7 +69,7 @@ class V {
       );
     }
     P.blendMode = t.blendMode;
-    const n = s.bindGroup.getBindGroup(
+    const i = s.bindGroup.getBindGroup(
       t.bindGroup,
       r,
       1
@@ -79,12 +79,12 @@ class V {
       P,
       t.topology
     );
-    t.bindGroup._touch(s.gc.now, s.tick), i.setPipeline(o), i.renderPassEncoder.setBindGroup(1, n), i.renderPassEncoder.drawIndexed(t.size, 1, t.start);
+    t.bindGroup._touch(s.gc.now, s.tick), n.setPipeline(o), n.renderPassEncoder.setBindGroup(1, i), n.renderPassEncoder.drawIndexed(t.size, 1, t.start);
   }
 }
 V.extension = {
   type: [
-    p.WebGPUPipesAdaptor
+    l.WebGPUPipesAdaptor
   ],
   name: "batch"
 };
@@ -99,48 +99,48 @@ class N {
     return e._updateKey(), this._hash[e._key] || this._createBindGroup(e, t, r);
   }
   _createBindGroup(e, t, r) {
-    const s = this._gpu.device, i = t.layout[r], n = [], o = this._renderer;
-    for (const f in i) {
-      const h = e.resources[f] ?? e.resources[i[f]];
-      let l;
+    const s = this._gpu.device, n = t.layout[r], i = [], o = this._renderer;
+    for (const f in n) {
+      const h = e.resources[f] ?? e.resources[n[f]];
+      let p;
       if (h._resourceType === "uniformGroup") {
         const d = h;
         o.ubo.updateUniformGroup(d);
         const g = d.buffer;
-        l = {
+        p = {
           buffer: o.buffer.getGPUBuffer(g),
           offset: 0,
           size: g.descriptor.size
         };
       } else if (h._resourceType === "buffer") {
         const d = h;
-        l = {
+        p = {
           buffer: o.buffer.getGPUBuffer(d),
           offset: 0,
           size: d.descriptor.size
         };
       } else if (h._resourceType === "bufferResource") {
         const d = h;
-        l = {
+        p = {
           buffer: o.buffer.getGPUBuffer(d.buffer),
           offset: d.offset,
           size: d.size
         };
       } else if (h._resourceType === "textureSampler") {
         const d = h;
-        l = o.texture.getGpuSampler(d);
+        p = o.texture.getGpuSampler(d);
       } else if (h._resourceType === "textureSource") {
         const d = h;
-        l = o.texture.getTextureView(d);
+        p = o.texture.getTextureView(d);
       }
-      n.push({
-        binding: i[f],
-        resource: l
+      i.push({
+        binding: n[f],
+        resource: p
       });
     }
     const u = o.shader.getProgramData(t).bindGroups[r], c = s.createBindGroup({
       layout: u,
-      entries: n
+      entries: i
     });
     return this._hash[e._key] = c, c;
   }
@@ -150,11 +150,11 @@ class N {
 }
 N.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "bindGroup"
 };
-class Le {
+class we {
   constructor(e) {
     this.gpuBuffer = e;
   }
@@ -162,7 +162,7 @@ class Le {
     this.gpuBuffer.destroy(), this.gpuBuffer = null;
   }
 }
-class j {
+class z {
   constructor(e) {
     this._renderer = e, this._managedBuffers = new k({
       renderer: e,
@@ -198,12 +198,12 @@ class j {
   }
   createGPUBuffer(e) {
     const t = this._gpu.device.createBuffer(e.descriptor);
-    return e._updateID = 0, e._resourceId = he("resource"), e.data && (ge(
+    return e._updateID = 0, e._resourceId = ce("resource"), e.data && (me(
       e.data.buffer,
       t.getMappedRange(),
       e.data.byteOffset,
       e.data.byteLength
-    ), t.unmap()), e._gpuData[this._renderer.uid] = new Le(t), this._managedBuffers.add(e) && (e.on("update", this.updateBuffer, this), e.on("change", this.onBufferChange, this)), t;
+    ), t.unmap()), e._gpuData[this._renderer.uid] = new we(t), this._managedBuffers.add(e) && (e.on("update", this.updateBuffer, this), e.on("change", this.onBufferChange, this)), t;
   }
   onBufferChange(e) {
     this._managedBuffers.remove(e), e._updateID = 0, this.createGPUBuffer(e);
@@ -212,13 +212,13 @@ class j {
     this._managedBuffers.destroy(), this._renderer = null, this._gpu = null;
   }
 }
-j.extension = {
+z.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "buffer"
 };
-class Ae {
+class Me {
   constructor({ minUniformOffsetAlignment: e }) {
     this._minUniformOffsetAlignment = 256, this.byteIndex = 0, this._minUniformOffsetAlignment = e, this.data = new Float32Array(65535);
   }
@@ -244,7 +244,7 @@ class Ae {
     this.data = null;
   }
 }
-class K {
+class j {
   constructor(e) {
     this._colorMaskCache = 15, this._renderer = e;
   }
@@ -255,13 +255,13 @@ class K {
     this._renderer = null, this._colorMaskCache = null;
   }
 }
-K.extension = {
+j.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "colorMask"
 };
-class w {
+class U {
   /**
    * @param {WebGPURenderer} renderer - The renderer this System works for.
    */
@@ -295,7 +295,7 @@ class w {
       "texture-compression-bc",
       "texture-compression-astc",
       "texture-compression-etc2"
-    ].filter((i) => t.features.has(i)), s = await t.requestDevice({
+    ].filter((n) => t.features.has(n)), s = await t.requestDevice({
       requiredFeatures: r
     });
     return { adapter: t, device: s };
@@ -304,13 +304,13 @@ class w {
     this.gpu = null, this._renderer = null;
   }
 }
-w.extension = {
+U.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "device"
 };
-w.defaultOptions = {
+U.defaultOptions = {
   /**
    * {@link WebGPUOptions.powerPreference}
    * @default default
@@ -322,7 +322,7 @@ w.defaultOptions = {
    */
   forceFallbackAdapter: !1
 };
-class q {
+class K {
   constructor(e) {
     this._boundBindGroup = /* @__PURE__ */ Object.create(null), this._boundVertexBuffer = /* @__PURE__ */ Object.create(null), this._renderer = e;
   }
@@ -341,8 +341,8 @@ class q {
     this.renderPassEncoder.setViewport(e.x, e.y, e.width, e.height, 0, 1);
   }
   setPipelineFromGeometryProgramAndState(e, t, r, s) {
-    const i = this._renderer.pipeline.getPipeline(e, t, r, s);
-    this.setPipeline(i);
+    const n = this._renderer.pipeline.getPipeline(e, t, r, s);
+    this.setPipeline(n);
   }
   setPipeline(e) {
     this._boundPipeline !== e && (this._boundPipeline = e, this.renderPassEncoder.setPipeline(e));
@@ -384,12 +384,12 @@ class q {
     }
   }
   draw(e) {
-    const { geometry: t, shader: r, state: s, topology: i, size: n, start: o, instanceCount: u, skipSync: c } = e;
-    this.setPipelineFromGeometryProgramAndState(t, r.gpuProgram, s, i), this.setGeometry(t, r.gpuProgram), this._setShaderBindGroups(r, c), t.indexBuffer ? this.renderPassEncoder.drawIndexed(
-      n || t.indexBuffer.data.length,
+    const { geometry: t, shader: r, state: s, topology: n, size: i, start: o, instanceCount: u, skipSync: c } = e;
+    this.setPipelineFromGeometryProgramAndState(t, r.gpuProgram, s, n), this.setGeometry(t, r.gpuProgram), this._setShaderBindGroups(r, c), t.indexBuffer ? this.renderPassEncoder.drawIndexed(
+      i || t.indexBuffer.data.length,
       u ?? t.instanceCount,
       o || 0
-    ) : this.renderPassEncoder.draw(n || t.getSize(), u ?? t.instanceCount, o || 0);
+    ) : this.renderPassEncoder.draw(i || t.getSize(), u ?? t.instanceCount, o || 0);
   }
   finishRenderPass() {
     this.renderPassEncoder && (this.renderPassEncoder.end(), this.renderPassEncoder = null);
@@ -409,14 +409,14 @@ class q {
       this._renderer.renderTarget.layer
     );
     this.renderPassEncoder = this.commandEncoder.beginRenderPass(e);
-    const t = this._boundPipeline, r = { ...this._boundVertexBuffer }, s = this._boundIndexBuffer, i = { ...this._boundBindGroup };
+    const t = this._boundPipeline, r = { ...this._boundVertexBuffer }, s = this._boundIndexBuffer, n = { ...this._boundBindGroup };
     this._clearCache();
-    const n = this._renderer.renderTarget.viewport;
-    this.renderPassEncoder.setViewport(n.x, n.y, n.width, n.height, 0, 1), this.setPipeline(t);
+    const i = this._renderer.renderTarget.viewport;
+    this.renderPassEncoder.setViewport(i.x, i.y, i.width, i.height, 0, 1), this.setPipeline(t);
     for (const o in r)
       this._setVertexBuffer(o, r[o]);
-    for (const o in i)
-      this.setBindGroup(o, i[o], null);
+    for (const o in n)
+      this.setBindGroup(o, n[o], null);
     this._setIndexBuffer(s);
   }
   _clearCache() {
@@ -431,12 +431,12 @@ class q {
     this._gpu = e;
   }
 }
-q.extension = {
-  type: [p.WebGPUSystem],
+K.extension = {
+  type: [l.WebGPUSystem],
   name: "encoder",
   priority: 1
 };
-class Y {
+class q {
   constructor(e) {
     this._renderer = e;
   }
@@ -446,20 +446,20 @@ class Y {
   destroy() {
   }
 }
-Y.extension = {
+q.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "limits"
 };
-class $ {
+class Y {
   constructor(e) {
     this._renderTargetStencilState = /* @__PURE__ */ Object.create(null), this._renderer = e, e.renderTarget.onRenderTargetChange.add(this);
   }
   onRenderTargetChange(e) {
     let t = this._renderTargetStencilState[e.uid];
     t || (t = this._renderTargetStencilState[e.uid] = {
-      stencilMode: v.DISABLED,
+      stencilMode: T.DISABLED,
       stencilReference: 0
     }), this._activeRenderTarget = e, this.setStencilMode(t.stencilMode, t.stencilReference);
   }
@@ -473,113 +473,20 @@ class $ {
     this._renderer.renderTarget.onRenderTargetChange.remove(this), this._renderer = null, this._activeRenderTarget = null, this._renderTargetStencilState = null;
   }
 }
-$.extension = {
+Y.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "stencil"
 };
-const B = {
-  i32: { align: 4, size: 4 },
-  u32: { align: 4, size: 4 },
-  f32: { align: 4, size: 4 },
-  f16: { align: 2, size: 2 },
-  "vec2<i32>": { align: 8, size: 8 },
-  "vec2<u32>": { align: 8, size: 8 },
-  "vec2<f32>": { align: 8, size: 8 },
-  "vec2<f16>": { align: 4, size: 4 },
-  "vec3<i32>": { align: 16, size: 12 },
-  "vec3<u32>": { align: 16, size: 12 },
-  "vec3<f32>": { align: 16, size: 12 },
-  "vec3<f16>": { align: 8, size: 6 },
-  "vec4<i32>": { align: 16, size: 16 },
-  "vec4<u32>": { align: 16, size: 16 },
-  "vec4<f32>": { align: 16, size: 16 },
-  "vec4<f16>": { align: 8, size: 8 },
-  "mat2x2<f32>": { align: 8, size: 16 },
-  "mat2x2<f16>": { align: 4, size: 8 },
-  "mat3x2<f32>": { align: 8, size: 24 },
-  "mat3x2<f16>": { align: 4, size: 12 },
-  "mat4x2<f32>": { align: 8, size: 32 },
-  "mat4x2<f16>": { align: 4, size: 16 },
-  "mat2x3<f32>": { align: 16, size: 32 },
-  "mat2x3<f16>": { align: 8, size: 16 },
-  "mat3x3<f32>": { align: 16, size: 48 },
-  "mat3x3<f16>": { align: 8, size: 24 },
-  "mat4x3<f32>": { align: 16, size: 64 },
-  "mat4x3<f16>": { align: 8, size: 32 },
-  "mat2x4<f32>": { align: 16, size: 32 },
-  "mat2x4<f16>": { align: 8, size: 16 },
-  "mat3x4<f32>": { align: 16, size: 48 },
-  "mat3x4<f16>": { align: 8, size: 24 },
-  "mat4x4<f32>": { align: 16, size: 64 },
-  "mat4x4<f16>": { align: 8, size: 32 }
-};
-function De(a) {
-  const e = a.map((r) => ({
-    data: r,
-    offset: 0,
-    size: 0
-  }));
-  let t = 0;
-  for (let r = 0; r < e.length; r++) {
-    const s = e[r];
-    let i = B[s.data.type].size;
-    const n = B[s.data.type].align;
-    if (!B[s.data.type])
-      throw new Error(`[Pixi.js] WebGPU UniformBuffer: Unknown type ${s.data.type}`);
-    s.data.size > 1 && (i = Math.max(i, n) * s.data.size), t = Math.ceil(t / n) * n, s.size = i, s.offset = t, t += i;
-  }
-  return t = Math.ceil(t / 16) * 16, { uboElements: e, size: t };
-}
-function ke(a, e) {
-  const { size: t, align: r } = B[a.data.type], s = (r - t) / 4, i = a.data.type.indexOf("i32") >= 0 ? "dataInt32" : "data";
-  return `
-         v = uv.${a.data.name};
-         ${e !== 0 ? `offset += ${e};` : ""}
-
-         arrayOffset = offset;
-
-         t = 0;
-
-         for(var i=0; i < ${a.data.size * (t / 4)}; i++)
-         {
-             for(var j = 0; j < ${t / 4}; j++)
-             {
-                 ${i}[arrayOffset++] = v[t++];
-             }
-             ${s !== 0 ? `arrayOffset += ${s};` : ""}
-         }
-     `;
-}
-function ze(a) {
-  return Ge(
-    a,
-    "uboWgsl",
-    ke,
-    Pe
-  );
-}
-class X extends Be {
-  constructor() {
-    super({
-      createUboElements: De,
-      generateUboSync: ze
-    });
-  }
-}
-X.extension = {
-  type: [p.WebGPUSystem],
-  name: "ubo"
-};
 const b = 128;
-class Z {
+class X {
   constructor(e) {
-    this._bindGroupHash = /* @__PURE__ */ Object.create(null), this._buffers = [], this._bindGroups = [], this._bufferResources = [], this._renderer = e, this._batchBuffer = new Ae({ minUniformOffsetAlignment: b });
+    this._bindGroupHash = /* @__PURE__ */ Object.create(null), this._buffers = [], this._bindGroups = [], this._bufferResources = [], this._renderer = e, this._batchBuffer = new Me({ minUniformOffsetAlignment: b });
     const t = 256 / b;
     for (let r = 0; r < t; r++) {
-      let s = T.UNIFORM | T.COPY_DST;
-      r === 0 && (s |= T.COPY_SRC), this._buffers.push(new Me({
+      let s = S.UNIFORM | S.COPY_DST;
+      r === 0 && (s |= S.COPY_SRC), this._buffers.push(new de({
         data: this._batchBuffer.data,
         usage: s
       }));
@@ -615,7 +522,7 @@ class Z {
   _getBufferResource(e) {
     if (!this._bufferResources[e]) {
       const t = this._buffers[e % 2];
-      this._bufferResources[e] = new Se({
+      this._bufferResources[e] = new he({
         buffer: t,
         offset: (e / 2 | 0) * 256,
         size: b
@@ -625,7 +532,7 @@ class Z {
   }
   _getBindGroup(e) {
     if (!this._bindGroups[e]) {
-      const t = new I({
+      const t = new H({
         0: this._getBufferResource(e)
       });
       this._bindGroups[e] = t;
@@ -637,11 +544,11 @@ class Z {
     t.update(this._batchBuffer.byteIndex), e.updateBuffer(t);
     const r = this._renderer.gpu.device.createCommandEncoder();
     for (let s = 1; s < this._buffers.length; s++) {
-      const i = this._buffers[s];
+      const n = this._buffers[s];
       r.copyBufferToBuffer(
         e.getGPUBuffer(t),
         b,
-        e.getGPUBuffer(i),
+        e.getGPUBuffer(n),
         0,
         this._batchBuffer.byteIndex
       );
@@ -661,31 +568,31 @@ class Z {
     this._bufferResources = null, this._batchBuffer.destroy(), this._renderer = null;
   }
 }
-Z.extension = {
+X.extension = {
   type: [
-    p.WebGPUPipes
+    l.WebGPUPipes
   ],
   name: "uniformBatch"
 };
-const Fe = {
+const Re = {
   "point-list": 0,
   "line-list": 1,
   "line-strip": 2,
   "triangle-list": 3,
   "triangle-strip": 4
 };
-function Oe(a, e, t, r, s) {
+function Ee(a, e, t, r, s) {
   return a << 24 | e << 16 | t << 10 | r << 5 | s;
 }
-function Ie(a, e, t, r, s) {
+function Le(a, e, t, r, s) {
   return t << 8 | a << 5 | r << 3 | s << 1 | e;
 }
-class J {
+class $ {
   constructor(e) {
     this._moduleCache = /* @__PURE__ */ Object.create(null), this._bufferLayoutsCache = /* @__PURE__ */ Object.create(null), this._bindingNamesCache = /* @__PURE__ */ Object.create(null), this._pipeCache = /* @__PURE__ */ Object.create(null), this._pipeStateCaches = /* @__PURE__ */ Object.create(null), this._colorMask = 15, this._multisampleCount = 1, this._colorTargetCount = 1, this._renderer = e;
   }
   contextChange(e) {
-    this._gpu = e, this.setStencilMode(v.DISABLED), this._updatePipeHash();
+    this._gpu = e, this.setStencilMode(T.DISABLED), this._updatePipeHash();
   }
   setMultisampleCount(e) {
     this._multisampleCount !== e && (this._multisampleCount = e, this._updatePipeHash());
@@ -697,27 +604,27 @@ class J {
     this._colorMask !== e && (this._colorMask = e, this._updatePipeHash());
   }
   setStencilMode(e) {
-    this._stencilMode !== e && (this._stencilMode = e, this._stencilState = Te[e], this._updatePipeHash());
+    this._stencilMode !== e && (this._stencilMode = e, this._stencilState = Pe[e], this._updatePipeHash());
   }
   setPipeline(e, t, r, s) {
-    const i = this.getPipeline(e, t, r);
-    s.setPipeline(i);
+    const n = this.getPipeline(e, t, r);
+    s.setPipeline(n);
   }
   getPipeline(e, t, r, s) {
-    e._layoutKey || (ve(e, t.attributeData), this._generateBufferKey(e)), s || (s = e.topology);
-    const i = Oe(
+    e._layoutKey || (Be(e, t.attributeData), this._generateBufferKey(e)), s || (s = e.topology);
+    const n = Ee(
       e._layoutKey,
       t._layoutKey,
       r.data,
       r._blendModeId,
-      Fe[s]
+      Re[s]
     );
-    return this._pipeCache[i] ? this._pipeCache[i] : (this._pipeCache[i] = this._createPipeline(e, t, r, s), this._pipeCache[i]);
+    return this._pipeCache[n] ? this._pipeCache[n] : (this._pipeCache[n] = this._createPipeline(e, t, r, s), this._pipeCache[n]);
   }
   _createPipeline(e, t, r, s) {
-    const i = this._gpu.device, n = this._createVertexBufferLayouts(e, t), o = this._renderer.state.getColorTargets(r, this._colorTargetCount), u = this._stencilMode === v.RENDERING_MASK_ADD ? 0 : this._colorMask;
-    for (let l = 0; l < o.length; l++)
-      o[l].writeMask = u;
+    const n = this._gpu.device, i = this._createVertexBufferLayouts(e, t), o = this._renderer.state.getColorTargets(r, this._colorTargetCount), u = this._stencilMode === T.RENDERING_MASK_ADD ? 0 : this._colorMask;
+    for (let p = 0; p < o.length; p++)
+      o[p].writeMask = u;
     const c = this._renderer.shader.getProgramData(t).pipeline, f = {
       // TODO later check if its helpful to create..
       // layout,
@@ -725,7 +632,7 @@ class J {
         module: this._getModule(t.vertex.source),
         entryPoint: t.vertex.entryPoint,
         // geometry..
-        buffers: n
+        buffers: i
       },
       fragment: {
         module: this._getModule(t.fragment.source),
@@ -748,7 +655,7 @@ class J {
       format: "depth24plus-stencil8",
       depthWriteEnabled: r.depthTest,
       depthCompare: r.depthTest ? "less" : "always"
-    }), i.createRenderPipeline(f);
+    }), n.createRenderPipeline(f);
   }
   _getModule(e) {
     return this._moduleCache[e] || this._createModule(e);
@@ -763,23 +670,23 @@ class J {
     const t = [];
     let r = 0;
     const s = Object.keys(e.attributes).sort();
-    for (let n = 0; n < s.length; n++) {
-      const o = e.attributes[s[n]];
+    for (let i = 0; i < s.length; i++) {
+      const o = e.attributes[s[i]];
       t[r++] = o.offset, t[r++] = o.format, t[r++] = o.stride, t[r++] = o.instance;
     }
-    const i = t.join("|");
-    return e._layoutKey = E(i, "geometry"), e._layoutKey;
+    const n = t.join("|");
+    return e._layoutKey = M(n, "geometry"), e._layoutKey;
   }
   _generateAttributeLocationsKey(e) {
     const t = [];
     let r = 0;
     const s = Object.keys(e.attributeData).sort();
-    for (let n = 0; n < s.length; n++) {
-      const o = e.attributeData[s[n]];
+    for (let i = 0; i < s.length; i++) {
+      const o = e.attributeData[s[i]];
       t[r++] = o.location;
     }
-    const i = t.join("|");
-    return e._attributeLocationsKey = E(i, "programAttributes"), e._attributeLocationsKey;
+    const n = t.join("|");
+    return e._attributeLocationsKey = M(n, "programAttributes"), e._attributeLocationsKey;
   }
   /**
    * Returns a hash of buffer names mapped to bind locations.
@@ -791,16 +698,16 @@ class J {
   getBufferNamesToBind(e, t) {
     const r = e._layoutKey << 16 | t._attributeLocationsKey;
     if (this._bindingNamesCache[r]) return this._bindingNamesCache[r];
-    const s = this._createVertexBufferLayouts(e, t), i = /* @__PURE__ */ Object.create(null), n = t.attributeData;
+    const s = this._createVertexBufferLayouts(e, t), n = /* @__PURE__ */ Object.create(null), i = t.attributeData;
     for (let o = 0; o < s.length; o++) {
       const c = Object.values(s[o].attributes)[0].shaderLocation;
-      for (const f in n)
-        if (n[f].location === c) {
-          i[o] = f;
+      for (const f in i)
+        if (i[f].location === c) {
+          n[o] = f;
           break;
         }
     }
-    return this._bindingNamesCache[r] = i, i;
+    return this._bindingNamesCache[r] = n, n;
   }
   _createVertexBufferLayouts(e, t) {
     t._attributeLocationsKey || this._generateAttributeLocationsKey(t);
@@ -808,25 +715,25 @@ class J {
     if (this._bufferLayoutsCache[r])
       return this._bufferLayoutsCache[r];
     const s = [];
-    return e.buffers.forEach((i) => {
-      const n = {
+    return e.buffers.forEach((n) => {
+      const i = {
         arrayStride: 0,
         stepMode: "vertex",
         attributes: []
-      }, o = n.attributes;
+      }, o = i.attributes;
       for (const u in t.attributeData) {
         const c = e.attributes[u];
-        (c.divisor ?? 1) !== 1 && U(`Attribute ${u} has an invalid divisor value of '${c.divisor}'. WebGPU only supports a divisor value of 1`), c.buffer === i && (n.arrayStride = c.stride, n.stepMode = c.instance ? "instance" : "vertex", o.push({
+        (c.divisor ?? 1) !== 1 && v(`Attribute ${u} has an invalid divisor value of '${c.divisor}'. WebGPU only supports a divisor value of 1`), c.buffer === n && (i.arrayStride = c.stride, i.stepMode = c.instance ? "instance" : "vertex", o.push({
           shaderLocation: t.attributeData[u].location,
           offset: c.offset,
           format: c.format
         }));
       }
-      o.length && s.push(n);
+      o.length && s.push(i);
     }), this._bufferLayoutsCache[r] = s, s;
   }
   _updatePipeHash() {
-    const e = Ie(
+    const e = Le(
       this._stencilMode,
       this._multisampleCount,
       this._colorMask,
@@ -839,45 +746,45 @@ class J {
     this._renderer = null, this._bufferLayoutsCache = null;
   }
 }
-J.extension = {
-  type: [p.WebGPUSystem],
+$.extension = {
+  type: [l.WebGPUSystem],
   name: "pipeline"
 };
-class We {
+class Ae {
   constructor() {
     this.contexts = [], this.msaaTextures = [], this.msaaSamples = 1;
   }
 }
-class He {
+class De {
   init(e, t) {
     this._renderer = e, this._renderTargetSystem = t;
   }
-  copyToTexture(e, t, r, s, i) {
-    const n = this._renderer, o = this._getGpuColorTexture(
+  copyToTexture(e, t, r, s, n) {
+    const i = this._renderer, o = this._getGpuColorTexture(
       e
-    ), u = n.texture.getGpuSource(
+    ), u = i.texture.getGpuSource(
       t.source
     );
-    return n.encoder.commandEncoder.copyTextureToTexture(
+    return i.encoder.commandEncoder.copyTextureToTexture(
       {
         texture: o,
         origin: r
       },
       {
         texture: u,
-        origin: i
+        origin: n
       },
       s
     ), t;
   }
-  startRenderPass(e, t = !0, r, s, i = 0, n = 0) {
+  startRenderPass(e, t = !0, r, s, n = 0, i = 0) {
     var f, h;
     const u = this._renderTargetSystem.getGpuRenderTarget(e);
-    if (n !== 0 && ((f = u.msaaTextures) != null && f.length))
+    if (i !== 0 && ((f = u.msaaTextures) != null && f.length))
       throw new Error("[RenderTargetSystem] Rendering to array layers is not supported with MSAA render targets.");
-    if (i > 0 && ((h = u.msaaTextures) != null && h.length))
+    if (n > 0 && ((h = u.msaaTextures) != null && h.length))
       throw new Error("[RenderTargetSystem] Rendering to mip levels is not supported with MSAA render targets.");
-    const c = this.getDescriptor(e, t, r, i, n);
+    const c = this.getDescriptor(e, t, r, n, i);
     u.descriptor = c, this._renderer.pipeline.setRenderTarget(u), this._renderer.encoder.beginRenderPass(u), this._renderer.encoder.setViewport(s);
   }
   finishRenderPass() {
@@ -895,14 +802,14 @@ class He {
       e.colorTextures[0].source
     );
   }
-  getDescriptor(e, t, r, s = 0, i = 0) {
+  getDescriptor(e, t, r, s = 0, n = 0) {
     typeof t == "boolean" && (t = t ? y.ALL : y.NONE);
-    const n = this._renderTargetSystem, o = n.getGpuRenderTarget(e), u = e.colorTextures.map(
-      (h, l) => {
-        const d = o.contexts[l];
+    const i = this._renderTargetSystem, o = i.getGpuRenderTarget(e), u = e.colorTextures.map(
+      (h, p) => {
+        const d = o.contexts[p];
         let g, m;
         if (d) {
-          if (i !== 0)
+          if (n !== 0)
             throw new Error("[RenderTargetSystem] Rendering to array layers is not supported for canvas targets.");
           g = d.getCurrentTexture().createView();
         } else
@@ -911,14 +818,14 @@ class He {
             dimension: "2d",
             baseMipLevel: s,
             mipLevelCount: 1,
-            baseArrayLayer: i,
+            baseArrayLayer: n,
             arrayLayerCount: 1
           });
-        o.msaaTextures[l] && (m = g, g = this._renderer.texture.getTextureView(
-          o.msaaTextures[l]
+        o.msaaTextures[p] && (m = g, g = this._renderer.texture.getTextureView(
+          o.msaaTextures[p]
         ));
         const G = t & y.COLOR ? "clear" : "load";
-        return r ?? (r = n.defaultClearColor), {
+        return r ?? (r = i.defaultClearColor), {
           view: g,
           resolveTarget: m,
           clearValue: r,
@@ -929,19 +836,19 @@ class He {
     );
     let c;
     if ((e.stencil || e.depth) && !e.depthStencilTexture && (e.ensureDepthStencilTexture(), e.depthStencilTexture.source.sampleCount = o.msaa ? 4 : 1), e.depthStencilTexture) {
-      const h = t & y.STENCIL ? "clear" : "load", l = t & y.DEPTH ? "clear" : "load";
+      const h = t & y.STENCIL ? "clear" : "load", p = t & y.DEPTH ? "clear" : "load";
       c = {
         view: this._renderer.texture.getGpuSource(e.depthStencilTexture.source).createView({
           dimension: "2d",
           baseMipLevel: s,
           mipLevelCount: 1,
-          baseArrayLayer: i,
+          baseArrayLayer: n,
           arrayLayerCount: 1
         }),
         stencilStoreOp: "store",
         stencilLoadOp: h,
         depthClearValue: 1,
-        depthLoadOp: l,
+        depthLoadOp: p,
         depthStoreOp: "store"
       };
     }
@@ -950,45 +857,45 @@ class He {
       depthStencilAttachment: c
     };
   }
-  clear(e, t = !0, r, s, i = 0, n = 0) {
+  clear(e, t = !0, r, s, n = 0, i = 0) {
     if (!t) return;
     const { gpu: o, encoder: u } = this._renderer, c = o.device;
     if (u.commandEncoder === null) {
-      const h = c.createCommandEncoder(), l = this.getDescriptor(e, t, r, i, n), d = h.beginRenderPass(l);
+      const h = c.createCommandEncoder(), p = this.getDescriptor(e, t, r, n, i), d = h.beginRenderPass(p);
       d.setViewport(s.x, s.y, s.width, s.height, 0, 1), d.end();
       const g = h.finish();
       c.queue.submit([g]);
     } else
-      this.startRenderPass(e, t, r, s, i, n);
+      this.startRenderPass(e, t, r, s, n, i);
   }
   initGpuRenderTarget(e) {
     e.isRoot = !0;
-    const t = new We();
+    const t = new Ae();
     return t.colorTargetCount = e.colorTextures.length, e.colorTextures.forEach((r, s) => {
-      if (r instanceof le) {
-        const i = r.resource.getContext(
+      if (r instanceof pe) {
+        const n = r.resource.getContext(
           "webgpu"
-        ), n = r.transparent ? "premultiplied" : "opaque";
+        ), i = r.transparent ? "premultiplied" : "opaque";
         try {
-          i.configure({
+          n.configure({
             device: this._renderer.gpu.device,
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
             format: "bgra8unorm",
-            alphaMode: n
+            alphaMode: i
           });
         } catch (o) {
           console.error(o);
         }
-        t.contexts[s] = i;
+        t.contexts[s] = n;
       }
       if (t.msaa = r.source.antialias, r.source.antialias) {
-        const i = new pe({
+        const n = new le({
           width: 0,
           height: 0,
           sampleCount: 4,
           arrayLayerCount: r.source.arrayLayerCount
         });
-        t.msaaTextures[s] = i;
+        t.msaaTextures[s] = n;
       }
     }), t.msaa && (t.msaaSamples = 4, e.depthStencilTexture && (e.depthStencilTexture.source.sampleCount = 4)), t;
   }
@@ -1006,8 +913,8 @@ class He {
   resizeGpuRenderTarget(e) {
     const t = this._renderTargetSystem.getGpuRenderTarget(e);
     t.width = e.width, t.height = e.height, t.msaa && e.colorTextures.forEach((r, s) => {
-      const i = t.msaaTextures[s];
-      i == null || i.resize(
+      const n = t.msaaTextures[s];
+      n == null || n.resize(
         r.source.width,
         r.source.height,
         r.source._resolution
@@ -1015,16 +922,16 @@ class He {
     });
   }
 }
-class Q extends me {
+class J extends _e {
   constructor(e) {
-    super(e), this.adaptor = new He(), this.adaptor.init(e, this);
+    super(e), this.adaptor = new De(), this.adaptor.init(e, this);
   }
 }
-Q.extension = {
-  type: [p.WebGPUSystem],
+J.extension = {
+  type: [l.WebGPUSystem],
   name: "renderTarget"
 };
-class ee {
+class Q {
   constructor() {
     this._gpuProgramData = /* @__PURE__ */ Object.create(null);
   }
@@ -1035,7 +942,7 @@ class ee {
     return this._gpuProgramData[e._layoutKey] || this._createGPUProgramData(e);
   }
   _createGPUProgramData(e) {
-    const t = this._gpu.device, r = e.gpuLayout.map((i) => t.createBindGroupLayout({ entries: i })), s = { bindGroupLayouts: r };
+    const t = this._gpu.device, r = e.gpuLayout.map((n) => t.createBindGroupLayout({ entries: n })), s = { bindGroupLayouts: r };
     return this._gpuProgramData[e._layoutKey] = {
       bindGroups: r,
       pipeline: t.createPipelineLayout(s)
@@ -1045,9 +952,9 @@ class ee {
     this._gpu = null, this._gpuProgramData = null;
   }
 }
-ee.extension = {
+Q.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "shader"
 };
@@ -1196,9 +1103,9 @@ _.max = {
     operation: "max"
   }
 };
-class te {
+class Z {
   constructor() {
-    this.defaultState = new O(), this.defaultState.blend = !0;
+    this.defaultState = new I(), this.defaultState.blend = !0;
   }
   contextChange(e) {
     this.gpu = e;
@@ -1209,36 +1116,36 @@ class te {
    * @param count - The number of color targets to create
    */
   getColorTargets(e, t) {
-    const r = _[e.blendMode] || _.normal, s = [], i = {
+    const r = _[e.blendMode] || _.normal, s = [], n = {
       format: "bgra8unorm",
       writeMask: 0,
       blend: r
     };
-    for (let n = 0; n < t; n++)
-      s[n] = i;
+    for (let i = 0; i < t; i++)
+      s[i] = n;
     return s;
   }
   destroy() {
     this.gpu = null;
   }
 }
-te.extension = {
+Z.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "state"
 };
-const Ve = {
+const ke = {
   type: "image",
   upload(a, e, t, r = 0) {
-    const s = a.resource, i = (a.pixelWidth | 0) * (a.pixelHeight | 0), n = s.byteLength / i;
+    const s = a.resource, n = (a.pixelWidth | 0) * (a.pixelHeight | 0), i = s.byteLength / n;
     t.device.queue.writeTexture(
       { texture: e, origin: { x: 0, y: 0, z: r } },
       s,
       {
         offset: 0,
         rowsPerImage: a.pixelHeight,
-        bytesPerRow: a.pixelWidth * n
+        bytesPerRow: a.pixelWidth * i
       },
       {
         width: a.pixelWidth,
@@ -1247,7 +1154,7 @@ const Ve = {
       }
     );
   }
-}, re = {
+}, ee = {
   "bc1-rgba-unorm": { blockBytes: 8, blockWidth: 4, blockHeight: 4 },
   "bc2-rgba-unorm": { blockBytes: 16, blockWidth: 4, blockHeight: 4 },
   "bc3-rgba-unorm": { blockBytes: 16, blockWidth: 4, blockHeight: 4 },
@@ -1255,13 +1162,13 @@ const Ve = {
   "etc1-rgb-unorm": { blockBytes: 8, blockWidth: 4, blockHeight: 4 },
   "etc2-rgba8unorm": { blockBytes: 16, blockWidth: 4, blockHeight: 4 },
   "astc-4x4-unorm": { blockBytes: 16, blockWidth: 4, blockHeight: 4 }
-}, Ne = { blockBytes: 4, blockWidth: 1, blockHeight: 1 }, je = {
+}, Fe = { blockBytes: 4, blockWidth: 1, blockHeight: 1 }, Oe = {
   type: "compressed",
   upload(a, e, t, r = 0) {
-    let s = a.pixelWidth, i = a.pixelHeight;
-    const n = re[a.format] || Ne;
+    let s = a.pixelWidth, n = a.pixelHeight;
+    const i = ee[a.format] || Fe;
     for (let o = 0; o < a.resource.length; o++) {
-      const u = a.resource[o], c = Math.ceil(s / n.blockWidth) * n.blockBytes;
+      const u = a.resource[o], c = Math.ceil(s / i.blockWidth) * i.blockBytes;
       t.device.queue.writeTexture(
         {
           texture: e,
@@ -1274,52 +1181,52 @@ const Ve = {
           bytesPerRow: c
         },
         {
-          width: Math.ceil(s / n.blockWidth) * n.blockWidth,
-          height: Math.ceil(i / n.blockHeight) * n.blockHeight,
+          width: Math.ceil(s / i.blockWidth) * i.blockWidth,
+          height: Math.ceil(n / i.blockHeight) * i.blockHeight,
           depthOrArrayLayers: 1
         }
-      ), s = Math.max(s >> 1, 1), i = Math.max(i >> 1, 1);
+      ), s = Math.max(s >> 1, 1), n = Math.max(n >> 1, 1);
     }
   }
-}, L = ["right", "left", "top", "bottom", "front", "back"];
-function Ke(a) {
+}, E = ["right", "left", "top", "bottom", "front", "back"];
+function Ie(a) {
   return {
     type: "cube",
     upload(e, t, r) {
       const s = e.faces;
-      for (let i = 0; i < L.length; i++) {
-        const n = L[i], o = s[n];
-        (a[o.uploadMethodId] || a.image).upload(o, t, r, i);
+      for (let n = 0; n < E.length; n++) {
+        const i = E[n], o = s[i];
+        (a[o.uploadMethodId] || a.image).upload(o, t, r, n);
       }
     }
   };
 }
-const se = {
+const te = {
   type: "image",
   upload(a, e, t, r = 0) {
     const s = a.resource;
     if (!s) return;
     if (globalThis.HTMLImageElement && s instanceof HTMLImageElement) {
       const u = x.get().createCanvas(s.width, s.height);
-      u.getContext("2d").drawImage(s, 0, 0, s.width, s.height), a.resource = u, U("ImageSource: Image element passed, converting to canvas and replacing resource.");
+      u.getContext("2d").drawImage(s, 0, 0, s.width, s.height), a.resource = u, v("ImageSource: Image element passed, converting to canvas and replacing resource.");
     }
-    const i = Math.min(e.width, a.resourceWidth || a.pixelWidth), n = Math.min(e.height, a.resourceHeight || a.pixelHeight), o = a.alphaMode === "premultiply-alpha-on-upload";
+    const n = Math.min(e.width, a.resourceWidth || a.pixelWidth), i = Math.min(e.height, a.resourceHeight || a.pixelHeight), o = a.alphaMode === "premultiply-alpha-on-upload";
     t.device.queue.copyExternalImageToTexture(
       { source: s },
       { texture: e, origin: { x: 0, y: 0, z: r }, premultipliedAlpha: o },
       {
-        width: i,
-        height: n
+        width: n,
+        height: i
       }
     );
   }
-}, qe = {
+}, He = {
   type: "video",
   upload(a, e, t, r) {
-    se.upload(a, e, t, r);
+    te.upload(a, e, t, r);
   }
 };
-class Ye {
+class We {
   constructor(e) {
     this.device = e, this.sampler = e.createSampler({ minFilter: "linear" }), this.pipelines = {};
   }
@@ -1377,8 +1284,8 @@ class Ye {
     if (e.dimension === "3d" || e.dimension === "1d")
       throw new Error("Generating mipmaps for non-2d textures is currently unsupported!");
     let r = e;
-    const s = e.depthOrArrayLayers || 1, i = e.usage & GPUTextureUsage.RENDER_ATTACHMENT;
-    if (!i) {
+    const s = e.depthOrArrayLayers || 1, n = e.usage & GPUTextureUsage.RENDER_ATTACHMENT;
+    if (!n) {
       const u = {
         size: {
           width: Math.ceil(e.width / 2),
@@ -1391,7 +1298,7 @@ class Ye {
       };
       r = this.device.createTexture(u);
     }
-    const n = this.device.createCommandEncoder({}), o = t.getBindGroupLayout(0);
+    const i = this.device.createCommandEncoder({}), o = t.getBindGroupLayout(0);
     for (let u = 0; u < s; ++u) {
       let c = e.createView({
         baseMipLevel: 0,
@@ -1399,17 +1306,17 @@ class Ye {
         dimension: "2d",
         baseArrayLayer: u,
         arrayLayerCount: 1
-      }), f = i ? 1 : 0;
+      }), f = n ? 1 : 0;
       for (let h = 1; h < e.mipLevelCount; ++h) {
-        const l = r.createView({
+        const p = r.createView({
           baseMipLevel: f++,
           mipLevelCount: 1,
           dimension: "2d",
           baseArrayLayer: u,
           arrayLayerCount: 1
-        }), d = n.beginRenderPass({
+        }), d = i.beginRenderPass({
           colorAttachments: [{
-            view: l,
+            view: p,
             storeOp: "store",
             loadOp: "clear",
             clearValue: { r: 0, g: 0, b: 0, a: 0 }
@@ -1424,17 +1331,17 @@ class Ye {
             resource: c
           }]
         });
-        d.setPipeline(t), d.setBindGroup(0, g), d.draw(3, 1, 0, 0), d.end(), c = l;
+        d.setPipeline(t), d.setBindGroup(0, g), d.draw(3, 1, 0, 0), d.end(), c = p;
       }
     }
-    if (!i) {
+    if (!n) {
       const u = {
         width: Math.ceil(e.width / 2),
         height: Math.ceil(e.height / 2),
         depthOrArrayLayers: s
       };
       for (let c = 1; c < e.mipLevelCount; ++c)
-        n.copyTextureToTexture({
+        i.copyTextureToTexture({
           texture: r,
           mipLevel: c - 1
         }, {
@@ -1442,10 +1349,10 @@ class Ye {
           mipLevel: c
         }, u), u.width = Math.ceil(u.width / 2), u.height = Math.ceil(u.height / 2);
     }
-    return this.device.queue.submit([n.finish()]), i || r.destroy(), e;
+    return this.device.queue.submit([i.finish()]), n || r.destroy(), e;
   }
 }
-class $e {
+class Ve {
   constructor(e) {
     this.textureView = null, this.gpuTexture = e;
   }
@@ -1454,7 +1361,7 @@ class $e {
     this.gpuTexture.destroy(), this.textureView = null, this.gpuTexture = null;
   }
 }
-class ie {
+class re {
   constructor(e) {
     this._gpuSamplers = /* @__PURE__ */ Object.create(null), this._bindGroupHash = /* @__PURE__ */ Object.create(null), this._renderer = e, e.gc.addCollection(this, "_bindGroupHash", "hash"), this._managedTextures = new k({
       renderer: e,
@@ -1463,14 +1370,14 @@ class ie {
       name: "gpuTextureSource"
     });
     const t = {
-      image: se,
-      buffer: Ve,
-      video: qe,
-      compressed: je
+      image: te,
+      buffer: ke,
+      video: He,
+      compressed: Oe
     };
     this._uploads = {
       ...t,
-      cube: Ke(t)
+      cube: Ie(t)
     };
   }
   /**
@@ -1498,23 +1405,23 @@ class ie {
     }
     let t = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
     e.uploadMethodId !== "compressed" && (t |= GPUTextureUsage.RENDER_ATTACHMENT, t |= GPUTextureUsage.COPY_SRC);
-    const r = re[e.format] || { blockWidth: 1, blockHeight: 1 }, s = Math.ceil(e.pixelWidth / r.blockWidth) * r.blockWidth, i = Math.ceil(e.pixelHeight / r.blockHeight) * r.blockHeight, n = {
+    const r = ee[e.format] || { blockWidth: 1, blockHeight: 1 }, s = Math.ceil(e.pixelWidth / r.blockWidth) * r.blockWidth, n = Math.ceil(e.pixelHeight / r.blockHeight) * r.blockHeight, i = {
       label: e.label,
-      size: { width: s, height: i, depthOrArrayLayers: e.arrayLayerCount },
+      size: { width: s, height: n, depthOrArrayLayers: e.arrayLayerCount },
       format: e.format,
       sampleCount: e.sampleCount,
       mipLevelCount: e.mipLevelCount,
       dimension: e.dimension,
       usage: t
-    }, o = this._gpu.device.createTexture(n);
-    return e._gpuData[this._renderer.uid] = new $e(o), this._managedTextures.add(e) && (e.on("update", this.onSourceUpdate, this), e.on("resize", this.onSourceResize, this), e.on("updateMipmaps", this.onUpdateMipmaps, this)), this.onSourceUpdate(e), o;
+    }, o = this._gpu.device.createTexture(i);
+    return e._gpuData[this._renderer.uid] = new Ve(o), this._managedTextures.add(e) && (e.on("update", this.onSourceUpdate, this), e.on("resize", this.onSourceResize, this), e.on("updateMipmaps", this.onUpdateMipmaps, this)), this.onSourceUpdate(e), o;
   }
   onSourceUpdate(e) {
     const t = this.getGpuSource(e);
     t && (this._uploads[e.uploadMethodId] && this._uploads[e.uploadMethodId].upload(e, t, this._gpu), e.autoGenerateMipmaps && e.mipLevelCount > 1 && this.onUpdateMipmaps(e));
   }
   onUpdateMipmaps(e) {
-    this._mipmapGenerator || (this._mipmapGenerator = new Ye(this._gpu.device));
+    this._mipmapGenerator || (this._mipmapGenerator = new We(this._gpu.device));
     const t = this.getGpuSource(e);
     this._mipmapGenerator.generateMipmap(t);
   }
@@ -1550,10 +1457,10 @@ class ie {
   }
   _createTextureBindGroup(e) {
     const t = e.source;
-    return this._bindGroupHash[e.uid] = new I({
+    return this._bindGroupHash[e.uid] = new H({
       0: t,
       1: t.style,
-      2: new W({
+      2: new L({
         uTextureMatrix: { type: "mat3x3<f32>", value: e.textureMatrix.mapCoord }
       })
     }), this._bindGroupHash[e.uid];
@@ -1567,8 +1474,8 @@ class ie {
   generateCanvas(e) {
     const t = this._renderer, r = t.gpu.device.createCommandEncoder(), s = x.get().createCanvas();
     s.width = e.source.pixelWidth, s.height = e.source.pixelHeight;
-    const i = s.getContext("webgpu");
-    return i.configure({
+    const n = s.getContext("webgpu");
+    return n.configure({
       device: t.gpu.device,
       usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
       format: x.get().getNavigator().gpu.getPreferredCanvasFormat(),
@@ -1580,7 +1487,7 @@ class ie {
         y: 0
       }
     }, {
-      texture: i.getCurrentTexture()
+      texture: n.getCurrentTexture()
     }, {
       width: s.width,
       height: s.height
@@ -1589,8 +1496,8 @@ class ie {
   getPixels(e) {
     const t = this.generateCanvas(e), r = C.getOptimalCanvasAndContext(t.width, t.height), s = r.context;
     s.drawImage(t, 0, 0);
-    const { width: i, height: n } = t, o = s.getImageData(0, 0, i, n), u = new Uint8ClampedArray(o.data.buffer);
-    return C.returnCanvasAndContext(r), { pixels: u, width: i, height: n };
+    const { width: n, height: i } = t, o = s.getImageData(0, 0, n, i), u = new Uint8ClampedArray(o.data.buffer);
+    return C.returnCanvasAndContext(r), { pixels: u, width: n, height: i };
   }
   destroy() {
     this._managedTextures.destroy();
@@ -1601,33 +1508,33 @@ class ie {
     this._renderer = null, this._gpu = null, this._mipmapGenerator = null, this._gpuSamplers = null, this._bindGroupHash = null;
   }
 }
-ie.extension = {
+re.extension = {
   type: [
-    p.WebGPUSystem
+    l.WebGPUSystem
   ],
   name: "texture"
 };
-class ne {
+class se {
   constructor() {
     this._maxTextures = 0;
   }
   contextChange(e) {
-    const t = new W({
+    const t = new L({
       uTransformMatrix: { value: new A(), type: "mat3x3<f32>" },
       uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
       uRound: { value: 0, type: "f32" }
     });
     this._maxTextures = e.limits.maxBatchableTextures;
-    const r = z({
+    const r = F({
       name: "graphics",
       bits: [
-        _e,
-        be(this._maxTextures),
-        Ce,
-        F
+        be,
+        ye(this._maxTextures),
+        Se,
+        O
       ]
     });
-    this.shader = new H({
+    this.shader = new W({
       gpuProgram: r,
       resources: {
         // added on the fly!
@@ -1636,19 +1543,19 @@ class ne {
     });
   }
   execute(e, t) {
-    const r = t.context, s = r.customShader || this.shader, i = e.renderer, n = i.graphicsContext, {
+    const r = t.context, s = r.customShader || this.shader, n = e.renderer, i = n.graphicsContext, {
       batcher: o,
       instructions: u
-    } = n.getContextRenderData(r), c = i.encoder;
+    } = i.getContextRenderData(r), c = n.encoder;
     c.setGeometry(o.geometry, s.gpuProgram);
-    const f = i.globalUniforms.bindGroup;
+    const f = n.globalUniforms.bindGroup;
     c.setBindGroup(0, f, s.gpuProgram);
-    const h = i.renderPipes.uniformBatch.getUniformBindGroup(s.resources.localUniforms, !0);
+    const h = n.renderPipes.uniformBatch.getUniformBindGroup(s.resources.localUniforms, !0);
     c.setBindGroup(2, h, s.gpuProgram);
-    const l = u.instructions;
+    const p = u.instructions;
     let d = null;
     for (let g = 0; g < u.instructionSize; g++) {
-      const m = l[g];
+      const m = p[g];
       if (m.topology !== d && (d = m.topology, c.setPipelineFromGeometryProgramAndState(
         o.geometry,
         s.gpuProgram,
@@ -1660,7 +1567,7 @@ class ne {
           G.textures,
           G.count,
           this._maxTextures
-        ), m.gpuBindGroup = i.bindGroup.getBindGroup(
+        ), m.gpuBindGroup = n.bindGroup.getBindGroup(
           m.bindGroup,
           s.gpuProgram,
           1
@@ -1673,23 +1580,23 @@ class ne {
     this.shader.destroy(!0), this.shader = null;
   }
 }
-ne.extension = {
+se.extension = {
   type: [
-    p.WebGPUPipesAdaptor
+    l.WebGPUPipesAdaptor
   ],
   name: "graphics"
 };
-class oe {
+class ne {
   init() {
-    const e = z({
+    const e = F({
       name: "mesh",
       bits: [
-        Ue,
-        we,
-        F
+        Te,
+        Ce,
+        O
       ]
     });
-    this._shader = new H({
+    this._shader = new W({
       gpuProgram: e,
       resources: {
         uTexture: R.EMPTY._source,
@@ -1706,13 +1613,13 @@ class oe {
     if (!s)
       s = this._shader, s.groups[2] = r.texture.getTextureBindGroup(t.texture);
     else if (!s.gpuProgram) {
-      U("Mesh shader has no gpuProgram", t.shader);
+      v("Mesh shader has no gpuProgram", t.shader);
       return;
     }
-    const i = s.gpuProgram;
-    if (i.autoAssignGlobalUniforms && (s.groups[0] = r.globalUniforms.bindGroup), i.autoAssignLocalUniforms) {
-      const n = e.localUniforms;
-      s.groups[1] = r.renderPipes.uniformBatch.getUniformBindGroup(n, !0);
+    const n = s.gpuProgram;
+    if (n.autoAssignGlobalUniforms && (s.groups[0] = r.globalUniforms.bindGroup), n.autoAssignLocalUniforms) {
+      const i = e.localUniforms;
+      s.groups[1] = r.renderPipes.uniformBatch.getUniformBindGroup(i, !0);
     }
     r.encoder.draw({
       geometry: t._geometry,
@@ -1724,45 +1631,45 @@ class oe {
     this._shader.destroy(!0), this._shader = null;
   }
 }
-oe.extension = {
+ne.extension = {
   type: [
-    p.WebGPUPipesAdaptor
+    l.WebGPUPipesAdaptor
   ],
   name: "mesh"
 };
-const Xe = [
-  ...ye,
-  X,
+const Ne = [
+  ...xe,
+  ge,
+  K,
+  U,
   q,
-  w,
-  Y,
-  j,
-  ie,
-  Q,
-  ee,
-  te,
+  z,
+  re,
   J,
-  K,
+  Q,
+  Z,
   $,
+  j,
+  Y,
   N
-], Ze = [...xe, Z], Je = [V, oe, ne], ae = [], ue = [], ce = [];
-S.handleByNamedList(p.WebGPUSystem, ae);
-S.handleByNamedList(p.WebGPUPipes, ue);
-S.handleByNamedList(p.WebGPUPipesAdaptor, ce);
-S.add(...Xe, ...Ze, ...Je);
-class ot extends fe {
+], ze = [...Ge, X], je = [V, ne, se], ie = [], oe = [], ae = [];
+B.handleByNamedList(l.WebGPUSystem, ie);
+B.handleByNamedList(l.WebGPUPipes, oe);
+B.handleByNamedList(l.WebGPUPipesAdaptor, ae);
+B.add(...Ne, ...ze, ...je);
+class Ze extends fe {
   constructor() {
     const e = {
       name: "webgpu",
-      type: Re.WEBGPU,
-      systems: ae,
-      renderPipes: ue,
-      renderPipeAdaptors: ce
+      type: ve.WEBGPU,
+      systems: ie,
+      renderPipes: oe,
+      renderPipeAdaptors: ae
     };
     super(e);
   }
 }
 export {
-  ot as WebGPURenderer
+  Ze as WebGPURenderer
 };
-//# sourceMappingURL=WebGPURenderer-SF1OSYpo.js.map
+//# sourceMappingURL=WebGPURenderer-89fMKfXn.js.map