aoi-comp 1.0.5 → 1.0.7

package/dist/WebGPURenderer-CfiYFIN2.js

@@ -1,1840 +0,0 @@
-import { n as e } from "./rolldown-runtime-CWhphoD1.js";
-import { R as t, V as n, W as r, b as i, c as a, d as o, et as s, g as c, it as l, l as u, n as d, o as f, r as p, rt as m, s as h, u as g, y as _ } from "./Geometry-CN7W9DnD.js";
-import { D as ee, O as v, T as te, d as y, g as ne, m as re, n as ie, r as ae, t as oe, v as se, w as b, x } from "./RenderTargetSystem-D_FiZPnb.js";
-import { t as S } from "./getTextureBatchBindGroup-CLFTP_Vc.js";
-import { t as C } from "./CanvasPool-C3aVgvEX.js";
-import { c as w, d as ce, i as le, l as ue, o as de, p as fe, r as pe, s as me, t as he } from "./BufferResource-CVU-ZRRz.js";
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/batcher/gpu/GpuBatchAdaptor.mjs
-var T = f.for2d(), E = class {
-	start(e, t, n) {
-		let r = e.renderer, i = r.encoder, a = n.gpuProgram;
-		this._shader = n, this._geometry = t, i.setGeometry(t, a), T.blendMode = "normal", r.pipeline.getPipeline(t, a, T, void 0, n._overrides);
-		let o = r.globalUniforms.bindGroup;
-		i.resetBindGroup(1), i.setBindGroup(0, o, a);
-	}
-	execute(e, t) {
-		let n = this._shader.gpuProgram, r = e.renderer, i = r.encoder;
-		if (!t.bindGroup) {
-			let e = t.textures;
-			t.bindGroup = S(e.textures, e.count, r.limits.maxBatchableTextures);
-		}
-		T.blendMode = t.blendMode;
-		let a = r.bindGroup.getBindGroup(t.bindGroup, n, 1), o = r.pipeline.getPipeline(this._geometry, n, T, t.topology, this._shader._overrides);
-		t.bindGroup._touch(r.gc.now, r.tick), i.setPipeline(o), i.renderPassEncoder.setBindGroup(1, a), i.renderPassEncoder.drawIndexed(t.size, 1, t.start);
-	}
-};
-E.extension = {
-	type: [m.WebGPUPipesAdaptor],
-	name: "batch"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/BindGroupSystem.mjs
-var D = class {
-	constructor(e) {
-		this._hash = /* @__PURE__ */ Object.create(null), this._renderer = e;
-	}
-	contextChange(e) {
-		this._gpu = e;
-	}
-	getBindGroup(e, t, n) {
-		let r = `${e._key}:${t._layoutKey << 4 | n}`;
-		return this._hash[r] || this._createBindGroup(r, e, t, n);
-	}
-	_createBindGroup(e, t, n, r) {
-		let i = this._gpu.device, a = n.layout[r], o = [], s = this._renderer;
-		for (let e in a) {
-			let n = t.resources[e] ?? t.resources[a[e]];
-			if (!n || n.destroyed) throw Error(`[BindGroup] the resource bound as '${e}' was destroyed while a shader still uses it. Remove it from the shader before destroying it.`);
-			let r;
-			if (n._resourceType === "uniformGroup") {
-				let e = n;
-				s.ubo.updateUniformGroup(e);
-				let t = e.buffer;
-				r = {
-					buffer: s.buffer.getGPUBuffer(t),
-					offset: 0,
-					size: t.descriptor.size
-				};
-			} else if (n._resourceType === "buffer") {
-				let e = n;
-				r = {
-					buffer: s.buffer.getGPUBuffer(e),
-					offset: 0,
-					size: e.descriptor.size
-				};
-			} else if (n._resourceType === "bufferResource") {
-				let e = n;
-				r = {
-					buffer: s.buffer.getGPUBuffer(e.buffer),
-					offset: e.offset,
-					size: e.size ?? e.buffer.descriptor.size
-				};
-			} else if (n._resourceType === "textureSampler") {
-				let e = n;
-				r = s.texture.getGpuSampler(e);
-			} else if (n._resourceType === "textureSource") {
-				let e = n;
-				r = s.texture.getTextureView(e);
-			} else if (n._resourceType === "textureView") {
-				let e = n;
-				r = s.texture.getTextureView(e.source, e.viewDescriptor);
-			}
-			o.push({
-				binding: a[e],
-				resource: r
-			});
-		}
-		let c = s.shader.getProgramData(n).bindGroups[r], l = i.createBindGroup({
-			layout: c,
-			entries: o
-		});
-		return this._hash[e] = l, l;
-	}
-	destroy() {
-		this._hash = null, this._renderer = null;
-	}
-};
-D.extension = {
-	type: [m.WebGPUSystem],
-	name: "bindGroup"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/buffer/GpuBufferSystem.mjs
-var ge = class {
-	constructor(e) {
-		this.gpuBuffer = e;
-	}
-	destroy() {
-		this.gpuBuffer.destroy(), this.gpuBuffer = null;
-	}
-}, O = class {
-	constructor(e) {
-		this._renderer = e, this._managedBuffers = new y({
-			renderer: e,
-			type: "resource",
-			onUnload: this.onBufferUnload.bind(this),
-			name: "gpuBuffer"
-		});
-	}
-	contextChange(e) {
-		this._gpu = e;
-	}
-	getGPUBuffer(e) {
-		return e._gcLastUsed = this._renderer.gc.now, e._gpuData[this._renderer.uid]?.gpuBuffer || this.createGPUBuffer(e);
-	}
-	updateBuffer(e) {
-		let t = this.getGPUBuffer(e), n = e.data;
-		return e._updateID && n && (e._updateID = 0, this._gpu.device.queue.writeBuffer(t, e._updateOffset, n.buffer, n.byteOffset + e._updateOffset, (e._updateSize || n.byteLength) + 3 & -4)), t;
-	}
-	destroyAll() {
-		this._managedBuffers.removeAll();
-	}
-	onBufferUnload(e) {
-		e.off("update", this.updateBuffer, this), e.off("change", this.onBufferChange, this);
-	}
-	createGPUBuffer(e) {
-		let t = this._gpu.device.createBuffer(e.descriptor);
-		return e._updateID = 0, e.data && (te(e.data.buffer, t.getMappedRange(), e.data.byteOffset, e.data.byteLength), t.unmap()), e._gpuData[this._renderer.uid] = new ge(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);
-	}
-	destroy() {
-		this._managedBuffers.destroy(), this._renderer = null, this._gpu = null;
-	}
-};
-O.extension = {
-	type: [m.WebGPUSystem],
-	name: "buffer"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/buffer/UboBatch.mjs
-var _e = class {
-	constructor({ minUniformOffsetAlignment: e }) {
-		this._minUniformOffsetAlignment = 256, this.byteIndex = 0, this._minUniformOffsetAlignment = e, this.data = /* @__PURE__ */ new Float32Array(65535);
-	}
-	clear() {
-		this.byteIndex = 0;
-	}
-	addEmptyGroup(e) {
-		if (e > this._minUniformOffsetAlignment / 4) throw Error(`UniformBufferBatch: array is too large: ${e * 4}`);
-		let t = this.byteIndex, n = t + e * 4;
-		if (n = Math.ceil(n / this._minUniformOffsetAlignment) * this._minUniformOffsetAlignment, n > this.data.length * 4) throw Error("UniformBufferBatch: ubo batch got too big");
-		return this.byteIndex = n, t;
-	}
-	addGroup(e) {
-		let t = this.addEmptyGroup(e.length);
-		for (let n = 0; n < e.length; n++) this.data[t / 4 + n] = e[n];
-		return t;
-	}
-	destroy() {
-		this.data = null;
-	}
-}, k = class {
-	constructor(e) {
-		this._colorMaskCache = 15, this._renderer = e;
-	}
-	setMask(e) {
-		this._colorMaskCache !== e && (this._colorMaskCache = e, this._renderer.pipeline.setColorMask(e));
-	}
-	destroy() {
-		this._renderer = null, this._colorMaskCache = null;
-	}
-};
-k.extension = {
-	type: [m.WebGPUSystem],
-	name: "colorMask"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/GpuDeviceSystem.mjs
-var A = class {
-	constructor(e) {
-		this._renderer = e;
-	}
-	async init(e) {
-		return this._initPromise ||= (e.gpu ? Promise.resolve(e.gpu) : this._createDeviceAndAdaptor(e)).then((e) => {
-			this.gpu = e, this.extensions = { transientAttachment: typeof GPUTextureUsage.TRANSIENT_ATTACHMENT == "number" }, this._renderer.runners.contextChange.emit(this.gpu);
-		}), this._initPromise;
-	}
-	contextChange(e) {
-		this._renderer.gpu = e;
-	}
-	async _createDeviceAndAdaptor(e) {
-		let t = await i.get().getNavigator().gpu.requestAdapter({
-			powerPreference: e.powerPreference,
-			forceFallbackAdapter: e.forceFallbackAdapter
-		});
-		if (!t) throw Error("WebGPU not supported. No GPU adapter was returned by navigator.gpu.requestAdapter().");
-		let n = [
-			"texture-compression-bc",
-			"texture-compression-astc",
-			"texture-compression-etc2",
-			"indirect-first-instance"
-		].filter((e) => t.features.has(e));
-		return {
-			adapter: t,
-			device: await t.requestDevice({
-				requiredFeatures: n,
-				requiredLimits: {
-					maxSampledTexturesPerShaderStage: t.limits.maxSampledTexturesPerShaderStage,
-					maxSamplersPerShaderStage: t.limits.maxSamplersPerShaderStage
-				}
-			})
-		};
-	}
-	destroy() {
-		this.gpu = null, this.extensions = null, this._renderer = null;
-	}
-};
-A.extension = {
-	type: [m.WebGPUSystem],
-	name: "device"
-}, A.defaultOptions = {
-	powerPreference: void 0,
-	forceFallbackAdapter: !1
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/GpuEncoderSystem.mjs
-var j = class {
-	constructor(e) {
-		this._boundBindGroup = /* @__PURE__ */ Object.create(null), this._boundVertexBuffer = /* @__PURE__ */ Object.create(null), this._renderer = e;
-		for (let e = 0; e < 16; e++) this._boundBindGroup[e] = {
-			bindGroup: null,
-			program: null,
-			key: null
-		};
-	}
-	renderStart() {
-		this.commandFinished = new Promise((e) => {
-			this._resolveCommandFinished = e;
-		}), this.commandEncoder = this._renderer.gpu.device.createCommandEncoder();
-	}
-	beginRenderPass(e) {
-		this.endRenderPass(), this._clearCache(), this._passEncoder = this.commandEncoder.beginRenderPass(e.descriptor), this.renderPassEncoder = this._passEncoder;
-	}
-	endRenderPass() {
-		this._passEncoder && this._passEncoder.end(), this.renderPassEncoder = null, this._passEncoder = null;
-	}
-	beginBundle() {
-		if (this._passEncoder !== this.renderPassEncoder) throw Error("Cannot begin a new render bundle while one is already being recorded.");
-		this._clearCache();
-		let e = this._renderer.pipeline.getBundleDescriptor();
-		this.renderPassEncoder = this._gpu.device.createRenderBundleEncoder(e);
-	}
-	endBundle() {
-		let e = this.renderPassEncoder;
-		if (!e || !("finish" in e)) throw Error("endBundle called without an active render bundle.");
-		let t = e.finish();
-		return this.renderPassEncoder = this._passEncoder, this._clearCache(), t;
-	}
-	executeBundle(e) {
-		this._clearCache(), this._passEncoder.executeBundles([e]);
-	}
-	setViewport(e) {
-		this._passEncoder.setViewport(e.x, e.y, e.width, e.height, 0, 1);
-	}
-	setStencilReference(e) {
-		this._passEncoder.setStencilReference(e);
-	}
-	setPipelineFromGeometryProgramAndState(e, t, n, r, i) {
-		let a = this._renderer.pipeline.getPipeline(e, t, n, r, i);
-		this.setPipeline(a);
-	}
-	setPipeline(e) {
-		this._boundPipeline !== e && (this._boundPipeline = e, this.renderPassEncoder.setPipeline(e));
-	}
-	_setVertexBuffer(e, t) {
-		this._boundVertexBuffer[e] !== t && (this._boundVertexBuffer[e] = t, this.renderPassEncoder.setVertexBuffer(e, this._renderer.buffer.updateBuffer(t)));
-	}
-	_setIndexBuffer(e) {
-		if (this._boundIndexBuffer === e) return;
-		this._boundIndexBuffer = e;
-		let t = e.data.BYTES_PER_ELEMENT === 2 ? "uint16" : "uint32";
-		this.renderPassEncoder.setIndexBuffer(this._renderer.buffer.updateBuffer(e), t);
-	}
-	resetBindGroup(e) {
-		let t = this._boundBindGroup[e];
-		t.bindGroup = null, t.program = null, t.key = null;
-	}
-	setBindGroup(e, t, n) {
-		let r = this._boundBindGroup[e];
-		if (r.bindGroup === t && r.program === n && r.key === t._key) return;
-		r.bindGroup = t, r.program = n, r.key = t._key, t._touch(this._renderer.gc.now, this._renderer.tick);
-		let i = this._renderer.bindGroup.getBindGroup(t, n, e);
-		this.renderPassEncoder.setBindGroup(e, i);
-	}
-	setGeometry(e, t) {
-		let n = this._renderer.pipeline.getBufferNamesToBind(e, t);
-		for (let t in n) this._setVertexBuffer(parseInt(t, 10), e.attributes[n[t]].buffer);
-		e.indexBuffer && this._setIndexBuffer(e.indexBuffer);
-	}
-	_setShaderBindGroups(e, t) {
-		let n = e.gpuProgram;
-		for (let r in e.groups) {
-			if (!n.layout[r]) continue;
-			let i = e.groups[r];
-			t || this._syncBindGroup(i), this.setBindGroup(r, i, n);
-		}
-	}
-	_syncBindGroup(e) {
-		for (let t in e.resources) {
-			let n = e.resources[t];
-			n && n.isUniformGroup && this._renderer.ubo.updateUniformGroup(n);
-		}
-	}
-	draw(e) {
-		let { geometry: t, shader: n, state: r, topology: i, size: a, start: o, baseVertex: s, instanceCount: c, skipSync: l, firstInstance: u } = e;
-		this.setPipelineFromGeometryProgramAndState(t, n.gpuProgram, r, i, n._overrides), this.setGeometry(t, n.gpuProgram), this._setShaderBindGroups(n, l), t.indexBuffer ? this.renderPassEncoder.drawIndexed(a || t.indexBuffer.data.length, c ?? t.instanceCount, o || 0, s || 0, u || 0) : this.renderPassEncoder.draw(a || t.vertexCount, c ?? t.instanceCount, o || 0, u || 0);
-	}
-	drawIndirect(e) {
-		let { geometry: t, shader: n, state: r, topology: i, skipSync: a, indirectBuffer: o, indirectOffset: s } = e;
-		this.setPipelineFromGeometryProgramAndState(t, n.gpuProgram, r, i, n._overrides), this.setGeometry(t, n.gpuProgram), this._setShaderBindGroups(n, a), t.indexBuffer ? this.renderPassEncoder.drawIndexedIndirect(o, s) : this.renderPassEncoder.drawIndirect(o, s);
-	}
-	finishRenderPass() {
-		this._passEncoder &&= (this._passEncoder.end(), this.renderPassEncoder = null, null);
-	}
-	postrender() {
-		this.finishRenderPass(), this._gpu.device.queue.submit([this.commandEncoder.finish()]), this._resolveCommandFinished(), this.commandEncoder = null;
-	}
-	_clearCache() {
-		for (let e = 0; e < 16; e++) {
-			let t = this._boundBindGroup[e];
-			t.bindGroup = null, t.program = null, t.key = null, this._boundVertexBuffer[e] = null;
-		}
-		this._boundIndexBuffer = null, this._boundPipeline = null;
-	}
-	destroy() {
-		this._renderer = null, this._gpu = null, this._boundBindGroup = null, this._boundVertexBuffer = null, this._boundIndexBuffer = null, this._boundPipeline = null, this.renderPassEncoder = null, this._passEncoder = null;
-	}
-	contextChange(e) {
-		this._gpu = e;
-	}
-};
-j.extension = {
-	type: [m.WebGPUSystem],
-	name: "encoder",
-	priority: 1
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/GpuLimitsSystem.mjs
-var M = class {
-	constructor(e) {
-		this.supportsOverrideConstants = !1, this._renderer = e;
-	}
-	contextChange() {
-		let e = this._renderer.device.gpu.device;
-		this.maxTextures = Math.min(e.limits.maxSampledTexturesPerShaderStage, e.limits.maxSamplersPerShaderStage), this.maxBatchableTextures = this.maxTextures, this._detectOverrideConstantsSupport(e);
-	}
-	_detectOverrideConstantsSupport(e) {
-		e.pushErrorScope("validation");
-		let t = e.createShaderModule({ code: "override TEST_VALUE: f32 = 0.0;\n@compute @workgroup_size(1) fn main() {}" });
-		e.createComputePipeline({
-			layout: "auto",
-			compute: {
-				module: t,
-				entryPoint: "main",
-				constants: { TEST_VALUE: 1 }
-			}
-		}), e.popErrorScope().then((e) => {
-			this.supportsOverrideConstants = !e;
-		});
-	}
-	destroy() {}
-};
-M.extension = {
-	type: [m.WebGPUSystem],
-	name: "limits"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/GpuStencilSystem.mjs
-var N = class {
-	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 ||= this._renderTargetStencilState[e.uid] = {
-			stencilMode: b.DISABLED,
-			stencilReference: 0
-		}, this._activeRenderTarget = e, this.setStencilMode(t.stencilMode, t.stencilReference);
-	}
-	setStencilMode(e, t) {
-		let n = this._renderTargetStencilState[this._activeRenderTarget.uid];
-		n.stencilMode = e, n.stencilReference = t;
-		let r = this._renderer;
-		r.pipeline.setStencilMode(e), r.encoder.setStencilReference(t);
-	}
-	destroy() {
-		this._renderer.renderTarget.onRenderTargetChange.remove(this), this._renderer = null, this._activeRenderTarget = null, this._renderTargetStencilState = null;
-	}
-};
-N.extension = {
-	type: [m.WebGPUSystem],
-	name: "stencil"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/shader/utils/createUboElementsWGSL.mjs
-var P = {
-	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 ve(e) {
-	let t = e.map((e) => ({
-		data: e,
-		offset: 0,
-		size: 0
-	})), n = 0;
-	for (let e = 0; e < t.length; e++) {
-		let r = t[e], i = P[r.data.type].size, a = P[r.data.type].align;
-		if (!P[r.data.type]) throw Error(`[Pixi.js] WebGPU UniformBuffer: Unknown type ${r.data.type}`);
-		r.data.size > 1 && (i = Math.max(i, a) * r.data.size), n = Math.ceil(n / a) * a, r.size = i, r.offset = n, n += i;
-	}
-	return n = Math.ceil(n / 16) * 16, {
-		uboElements: t,
-		size: n
-	};
-}
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/shader/utils/generateArraySyncWGSL.mjs
-function ye(e, t) {
-	let { size: n, align: r } = P[e.data.type], i = (r - n) / 4, a = e.data.type.indexOf("i32") >= 0 ? "dataInt32" : "data";
-	return `
-         v = uv.${e.data.name};
-         ${t === 0 ? "" : `offset += ${t};`}
-
-         arrayOffset = offset;
-
-         t = 0;
-
-         for(var i=0; i < ${e.data.size * (n / 4)}; i++)
-         {
-             for(var j = 0; j < ${n / 4}; j++)
-             {
-                 ${a}[arrayOffset++] = v[t++];
-             }
-             ${i === 0 ? "" : `arrayOffset += ${i};`}
-         }
-     `;
-}
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/shader/utils/createUboSyncFunctionWGSL.mjs
-function be(e) {
-	return le(e, pe, ye);
-}
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/GpuUboSystem.mjs
-var F = class extends de {
-	constructor() {
-		super({
-			createUboElements: ve,
-			generateUboSync: be
-		});
-	}
-};
-F.extension = {
-	type: [m.WebGPUSystem],
-	name: "ubo"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/GpuUniformBatchPipe.mjs
-var I = 128, L = class {
-	constructor(e) {
-		this._bindGroupHash = /* @__PURE__ */ Object.create(null), this._buffers = [], this._bindGroups = [], this._bufferResources = [], this._renderer = e, this._batchBuffer = new _e({ minUniformOffsetAlignment: I });
-		let t = 256 / I;
-		for (let e = 0; e < t; e++) {
-			let t = p.UNIFORM | p.COPY_DST;
-			e === 0 && (t |= p.COPY_SRC), this._buffers.push(new d({
-				data: this._batchBuffer.data,
-				usage: t
-			}));
-		}
-	}
-	renderEnd() {
-		this._uploadBindGroups(), this._resetBindGroups();
-	}
-	_resetBindGroups() {
-		this._bindGroupHash = /* @__PURE__ */ Object.create(null), this._batchBuffer.clear();
-	}
-	getUniformBindGroup(e, t) {
-		if (!t && this._bindGroupHash[e.uid]) return this._bindGroupHash[e.uid];
-		this._renderer.ubo.ensureUniformGroup(e);
-		let n = e.buffer.data, r = this._batchBuffer.addEmptyGroup(n.length);
-		return this._renderer.ubo.syncUniformGroup(e, this._batchBuffer.data, r / 4), this._bindGroupHash[e.uid] = this._getBindGroup(r / I), this._bindGroupHash[e.uid];
-	}
-	getUboResource(e) {
-		this._renderer.ubo.updateUniformGroup(e);
-		let t = e.buffer.data, n = this._batchBuffer.addGroup(t);
-		return this._getBufferResource(n / I);
-	}
-	getArrayBindGroup(e) {
-		let t = this._batchBuffer.addGroup(e);
-		return this._getBindGroup(t / I);
-	}
-	getArrayBufferResource(e) {
-		let t = this._batchBuffer.addGroup(e) / I;
-		return this._getBufferResource(t);
-	}
-	_getBufferResource(e) {
-		if (!this._bufferResources[e]) {
-			let t = this._buffers[e % 2];
-			this._bufferResources[e] = new he({
-				buffer: t,
-				offset: (e / 2 | 0) * 256,
-				size: I
-			});
-		}
-		return this._bufferResources[e];
-	}
-	_getBindGroup(e) {
-		if (!this._bindGroups[e]) {
-			let t = new g({ 0: this._getBufferResource(e) });
-			this._bindGroups[e] = t;
-		}
-		return this._bindGroups[e];
-	}
-	_uploadBindGroups() {
-		let e = this._renderer.buffer, t = this._buffers[0];
-		t.update(this._batchBuffer.byteIndex), e.updateBuffer(t);
-		let n = this._renderer.gpu.device.createCommandEncoder();
-		for (let r = 1; r < this._buffers.length; r++) {
-			let i = this._buffers[r];
-			n.copyBufferToBuffer(e.getGPUBuffer(t), I, e.getGPUBuffer(i), 0, this._batchBuffer.byteIndex);
-		}
-		this._renderer.gpu.device.queue.submit([n.finish()]);
-	}
-	destroy() {
-		for (let e = 0; e < this._bindGroups.length; e++) this._bindGroups[e]?.destroy();
-		this._bindGroups = null, this._bindGroupHash = null;
-		for (let e = 0; e < this._buffers.length; e++) this._buffers[e].destroy();
-		this._buffers = null;
-		for (let e = 0; e < this._bufferResources.length; e++) this._bufferResources[e].destroy();
-		this._bufferResources = null, this._batchBuffer.destroy(), this._renderer = null;
-	}
-};
-L.extension = {
-	type: [m.WebGPUPipes],
-	name: "uniformBatch"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/pipeline/PipelineSystem.mjs
-var R = {
-	"point-list": 0,
-	"line-list": 1,
-	"line-strip": 2,
-	"triangle-list": 3,
-	"triangle-strip": 4
-}, xe = new a({}), Se = {
-	"depth24plus-stencil8": {
-		depth: !0,
-		stencil: !0,
-		index: 1
-	},
-	depth24plus: {
-		depth: !0,
-		stencil: !1,
-		index: 2
-	},
-	depth32float: {
-		depth: !0,
-		stencil: !1,
-		index: 3
-	},
-	"depth32float-stencil8": {
-		depth: !0,
-		stencil: !0,
-		index: 4
-	},
-	depth16unorm: {
-		depth: !0,
-		stencil: !1,
-		index: 5
-	},
-	stencil8: {
-		depth: !1,
-		stencil: !0,
-		index: 6
-	}
-}, z = {
-	depth: !1,
-	stencil: !1,
-	index: 0
-};
-function Ce(e, t) {
-	for (let [n, r] of Object.entries(t)) {
-		let t = RegExp(`override\\s+${n}\\s*:\\s*(\\w+)\\s*(?:=[^;]*)?;`);
-		e = e.replace(t, (e, t) => {
-			let i;
-			return i = t === "u32" ? `${Math.trunc(r)}u` : t === "i32" ? `${Math.trunc(r)}` : Number.isInteger(r) ? `${r}.0` : `${r}`, `const ${n}: ${t} = ${i};`;
-		});
-	}
-	return e;
-}
-function B(e, t, n, r, i, a) {
-	return e * 35184372088832 + t * 536870912 + a * 16384 + (n << 8) + (r << 3) + i;
-}
-var V = /* @__PURE__ */ Object.create(null), we = 0;
-function H(e) {
-	let t = V[e];
-	return t === void 0 && (t = V[e] = we++), t;
-}
-function Te(e, t, n, r, i, a, o, s) {
-	return s << 20 | a << 16 | i << 13 | n << 9 | e << 6 | o << 5 | r << 1 | t;
-}
-var U = class {
-	constructor(e) {
-		this._moduleCache = /* @__PURE__ */ Object.create(null), this._bufferLayoutsCache = /* @__PURE__ */ Object.create(null), this._bindingNamesCache = /* @__PURE__ */ Object.create(null), this._pipeCache = /* @__PURE__ */ new Map(), this._pipeStateCaches = /* @__PURE__ */ Object.create(null), this._colorMask = 15, this._multisampleCount = 1, this._colorTargetCount = 1, this._colorFormat = "bgra8unorm", this._colorFormatId = H("bgra8unorm"), this._depthStencilFormat = "depth24plus-stencil8", this._depthStencilFormatData = z, this._depthReadOnly = !1, this._invertFrontFace = !1, this._renderer = e;
-	}
-	contextChange(e) {
-		this._gpu = e, this.setStencilMode(b.DISABLED), this._updatePipeHash();
-	}
-	setMultisampleCount(e) {
-		this._multisampleCount !== e && (this._multisampleCount = e, this._updatePipeHash());
-	}
-	setRenderTarget(e) {
-		let t = e.colorAttachments[0]?.texture;
-		this._multisampleCount = t?.source.antialias ? 4 : 1, this._colorTargetCount = e.colorAttachments.length, this._colorFormat = t?.format ?? "bgra8unorm", this._colorFormatId = H(this._colorFormat), this._depthStencilFormat = e.depthStencilAttachment?.texture.format, this._depthStencilFormatData = Se[this._depthStencilFormat] || z, this._depthReadOnly = e.depthStencilAttachment?.depthReadOnly ?? !1, this._invertFrontFace = !!e.flipY, this._updatePipeHash();
-	}
-	setColorMask(e) {
-		this._colorMask !== e && (this._colorMask = e, this._updatePipeHash());
-	}
-	setStencilMode(e) {
-		this._stencilMode !== e && (this._stencilMode = e, this._stencilState = me[e], this._updatePipeHash());
-	}
-	getBundleDescriptor() {
-		let e = [];
-		for (let t = 0; t < this._colorTargetCount; t++) e.push(this._colorFormat);
-		let t = {
-			colorFormats: e,
-			sampleCount: this._multisampleCount
-		};
-		return (this._depthStencilFormatData.depth || this._depthStencilFormatData.stencil) && (t.depthStencilFormat = this._depthStencilFormat), t;
-	}
-	setPipeline(e, t, n, r) {
-		let i = this.getPipeline(e, t, n);
-		r.setPipeline(i);
-	}
-	getPipelineKey(e, t, n, r, i) {
-		return e._layoutKey || (w(e, t.attributeData), this._generateBufferKey(e)), B(e._layoutKey, t._layoutKey, n.data, n._blendModeId, R[r], i.id);
-	}
-	getPipeline(e, t, n, r, i) {
-		e._layoutKey || (w(e, t.attributeData), this._generateBufferKey(e)), r ||= e.topology, i ||= xe;
-		let a = B(e._layoutKey, t._layoutKey, n.data, n._blendModeId, R[r], i.id), o = this._pipeCache.get(a);
-		return o || (o = this._createPipeline(e, t, n, r, i), this._pipeCache.set(a, o)), o;
-	}
-	_createPipeline(e, t, n, r, i) {
-		let a = this._gpu.device, o = this._createVertexBufferLayouts(e, t), s = this._renderer.state.getColorTargets(n, this._colorTargetCount, this._colorFormat), c = this._stencilMode === b.RENDERING_MASK_ADD ? 0 : this._colorMask;
-		for (let e = 0; e < s.length; e++) s[e].writeMask = c;
-		let l = this._renderer.shader.getProgramData(t).pipeline, u = Object.keys(i.data).length > 0, d = t.vertex.source, f = t.fragment.source, p;
-		u && (this._renderer.limits.supportsOverrideConstants ? p = i.data : (d = Ce(d, i.data), f = Ce(f, i.data)));
-		let m = {
-			vertex: {
-				module: this._getModule(d),
-				entryPoint: t.vertex.entryPoint,
-				constants: p,
-				buffers: o
-			},
-			fragment: {
-				module: this._getModule(f),
-				entryPoint: t.fragment.entryPoint,
-				targets: s,
-				constants: p
-			},
-			primitive: {
-				topology: r,
-				cullMode: n.culling ? "back" : "none",
-				frontFace: n.clockwiseFrontFace === this._invertFrontFace ? "ccw" : "cw"
-			},
-			layout: l,
-			multisample: { count: this._multisampleCount },
-			label: t.name ? `PIXI Pipeline (${t.name})` : "PIXI Pipeline"
-		};
-		if (this._depthStencilFormatData.depth || this._depthStencilFormatData.stencil) {
-			let e = this._depthStencilFormatData;
-			m.depthStencil = {
-				...this._stencilState,
-				format: this._depthStencilFormat,
-				depthWriteEnabled: e.depth ? n.depthMask && !this._depthReadOnly : !1,
-				depthCompare: e.depth && n.depthTest ? "less" : "always"
-			};
-		}
-		return a.createRenderPipeline(m);
-	}
-	_getModule(e) {
-		return this._moduleCache[e] || this._createModule(e);
-	}
-	_createModule(e) {
-		let t = this._gpu.device;
-		return this._moduleCache[e] = t.createShaderModule({ code: e }), this._moduleCache[e];
-	}
-	_generateBufferKey(e) {
-		let t = [], n = 0, r = Object.keys(e.attributes).sort();
-		for (let i = 0; i < r.length; i++) {
-			let a = e.attributes[r[i]];
-			t[n++] = a.offset, t[n++] = a.format, t[n++] = a.stride, t[n++] = a.instance;
-		}
-		return e._layoutKey = c(t.join("|"), "geometry"), e._layoutKey;
-	}
-	_generateAttributeLocationsKey(e) {
-		let t = [], n = 0, r = Object.keys(e.attributeData).sort();
-		for (let i = 0; i < r.length; i++) {
-			let a = e.attributeData[r[i]];
-			t[n++] = a.location;
-		}
-		return e._attributeLocationsKey = c(t.join("|"), "programAttributes"), e._attributeLocationsKey;
-	}
-	getBufferNamesToBind(e, t) {
-		let n = e._layoutKey << 16 | t._attributeLocationsKey;
-		if (this._bindingNamesCache[n]) return this._bindingNamesCache[n];
-		let r = this._createVertexBufferLayouts(e, t), i = /* @__PURE__ */ Object.create(null), a = t.attributeData;
-		for (let e = 0; e < r.length; e++) {
-			let t = Object.values(r[e].attributes)[0].shaderLocation;
-			for (let n in a) if (a[n].location === t) {
-				i[e] = n;
-				break;
-			}
-		}
-		return this._bindingNamesCache[n] = i, i;
-	}
-	_createVertexBufferLayouts(e, n) {
-		n._attributeLocationsKey || this._generateAttributeLocationsKey(n);
-		let r = e._layoutKey << 16 | n._attributeLocationsKey;
-		if (this._bufferLayoutsCache[r]) return this._bufferLayoutsCache[r];
-		let i = [];
-		return e.buffers.forEach((r) => {
-			let a = {
-				arrayStride: 0,
-				stepMode: "vertex",
-				attributes: []
-			}, o = a.attributes;
-			for (let i in n.attributeData) {
-				let s = e.attributes[i];
-				(s.divisor ?? 1) !== 1 && t(`Attribute ${i} has an invalid divisor value of '${s.divisor}'. WebGPU only supports a divisor value of 1`), s.buffer === r && (a.arrayStride = s.stride, a.stepMode = s.instance ? "instance" : "vertex", o.push({
-					shaderLocation: n.attributeData[i].location,
-					offset: s.offset,
-					format: s.format
-				}));
-			}
-			o.length && i.push(a);
-		}), this._bufferLayoutsCache[r] = i, i;
-	}
-	_updatePipeHash() {
-		var e;
-		let t = Te(this._stencilMode, this._multisampleCount === 1 ? 0 : 1, this._colorMask, this._colorTargetCount, this._depthStencilFormatData.index, this._colorFormatId, +!!this._depthReadOnly, +!!this._invertFrontFace);
-		this._pipeCache = (e = this._pipeStateCaches)[t] ?? (e[t] = /* @__PURE__ */ new Map());
-	}
-	destroy() {
-		this._bufferLayoutsCache = null, this._pipeCache = null, this._gpu = null, this._renderer = null, this._bindingNamesCache = null, this._pipeStateCaches = null, this._moduleCache = null;
-	}
-};
-U.extension = {
-	type: [m.WebGPUSystem],
-	name: "pipeline"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/renderTarget/GpuRenderTarget.mjs
-var Ee = class {
-	constructor() {
-		this.contexts = [], this.msaaTextures = [], this.msaaSamples = 1;
-	}
-}, De = {
-	bgra8unorm: !0,
-	rgba8unorm: !0,
-	rgba16float: !0
-};
-function Oe(e) {
-	if (De[e]) return e;
-	let n = navigator.gpu.getPreferredCanvasFormat();
-	return t(`[WebGPU] CanvasSource format '${e}' is not a valid GPUCanvasContext format. Falling back to '${n}'. Allowed formats are: bgra8unorm, rgba8unorm, rgba16float.`), n;
-}
-var ke = class {
-	constructor() {
-		this._activePass = null;
-	}
-	init(e, t) {
-		this._renderer = e, this._renderTargetSystem = t;
-	}
-	copyToTexture(e, t, n, r, i) {
-		let a = this._renderer;
-		this.finishRenderPass();
-		let o = this._getGpuColorTexture(e), s = a.texture.getGpuSource(t.source);
-		return a.encoder.commandEncoder.copyTextureToTexture({
-			texture: o,
-			origin: n
-		}, {
-			texture: s,
-			origin: i
-		}, r), t;
-	}
-	copyDepthTexture(e, t, n, r, i) {
-		let a = this._renderer;
-		this.finishRenderPass();
-		let o = e.depthStencilAttachment.texture, s = a.texture.getGpuSource(o), c = a.texture.getGpuSource(t.source), l = a.encoder.commandEncoder === null, u = l ? a.gpu.device.createCommandEncoder() : a.encoder.commandEncoder;
-		u.copyTextureToTexture({
-			texture: s,
-			origin: n
-		}, {
-			texture: c,
-			origin: i
-		}, {
-			width: r.width,
-			height: r.height
-		}), l && a.gpu.device.queue.submit([u.finish()]);
-	}
-	startRenderPass(e, t = !0, n, r, i = 0, a = 0) {
-		let o = this._renderTargetSystem.getGpuRenderTarget(e);
-		if (a !== 0 && o.msaaTextures?.length) throw Error("[RenderTargetSystem] Rendering to array layers is not supported with MSAA render targets.");
-		if (i > 0 && o.msaaTextures?.length) throw Error("[RenderTargetSystem] Rendering to mip levels is not supported with MSAA render targets.");
-		let s = t;
-		typeof s == "boolean" && (s = s ? v.ALL : v.NONE), (e.stencil || e.depth) && !e.depthStencilAttachment && e.ensureDepthStencilTexture();
-		let c = !!e.depthStencilAttachment, l = this._activePass;
-		if (l !== null && l.renderTarget === e && l.mipLevel === i && l.layer === a && l.depthStencil === c && this._renderer.encoder.renderPassEncoder !== null && s === v.NONE) {
-			this._renderer.encoder.setViewport(r);
-			return;
-		}
-		o.descriptor = this.getDescriptor(e, t, n, i, a), this._renderer.pipeline.setRenderTarget(e), this._renderer.encoder.beginRenderPass(o), this._renderer.encoder.setViewport(r), this._activePass = {
-			renderTarget: e,
-			mipLevel: i,
-			layer: a,
-			depthStencil: c
-		};
-	}
-	finishRenderPass() {
-		this._renderer.encoder.endRenderPass(), this._activePass = null;
-	}
-	_getGpuColorTexture(e) {
-		if (e.colorAttachments.length === 0) throw Error("[GpuRenderTargetAdaptor] cannot get gpu color texture from a depth-only render target");
-		let t = e.colorAttachments[0].texture;
-		return t instanceof _ && t._gpuContext ? t._gpuContext.getCurrentTexture() : this._renderer.texture.getGpuSource(t);
-	}
-	getDescriptor(e, t, n, r = 0, i = 0) {
-		typeof t == "boolean" && (t = t ? v.ALL : v.NONE);
-		let a = this._renderTargetSystem, o = a.getGpuRenderTarget(e), s = e.colorAttachments.map((e, s) => {
-			let c = e.texture, l = c instanceof _ ? c._gpuContext : null, u, d;
-			if (l) {
-				if (i !== 0) throw Error("[RenderTargetSystem] Rendering to array layers is not supported for canvas targets.");
-				u = l.getCurrentTexture().createView(e.viewDescriptor);
-			} else u = this._renderer.texture.getTextureRenderTargetView(e.texture, r, i, e.viewDescriptor);
-			let f = !1;
-			o.msaaTextures[s] && (d = u, u = this._renderer.texture.getTextureView(o.msaaTextures[s]), f = o.msaaTextures[s].transient);
-			let p = e.loadOp;
-			t !== void 0 && (p = t & v.COLOR ? "clear" : "load"), n ??= a.defaultClearColor;
-			let m = e.storeOp ?? "store", h = {
-				view: u,
-				resolveTarget: d,
-				storeOp: f ? "discard" : m,
-				loadOp: p
-			};
-			p === "clear" && (n ??= e.clearValue ?? a.defaultClearColor, h.clearValue = n);
-			for (let t in e) t !== "texture" && t !== "viewDescriptor" && t !== "clearValue" && t !== "loadOp" && t !== "storeOp" && (h[t] = e[t]);
-			return h;
-		}), c;
-		if (e.depthStencilAttachment) {
-			o.msaa && (e.depthStencilAttachment.texture.sampleCount = 4), e.depthStencilAttachment.texture.transient = !!o.msaaTextures[0]?.transient;
-			let n = e.depthStencilAttachment, a = n.texture.format.includes("stencil"), s = n.texture.format.includes("depth"), l = n.texture.transient ? "discard" : "store";
-			c = { view: this._renderer.texture.getTextureRenderTargetView(n.texture, r, i, n.viewDescriptor) };
-			let u = n.depthReadOnly ?? !1, d = n.stencilReadOnly ?? u;
-			a && !d ? (c.stencilLoadOp = t & v.STENCIL ? "clear" : n.stencilLoadOp ?? "load", c.stencilStoreOp = n.stencilStoreOp ?? l, c.stencilLoadOp === "clear" && (c.stencilClearValue = n.stencilClearValue ?? 0)) : a && d && (c.stencilReadOnly = !0), s && !u ? (c.depthLoadOp = t & v.DEPTH ? "clear" : n.depthLoadOp ?? "load", c.depthStoreOp = n.depthStoreOp ?? l, c.depthLoadOp === "clear" && (c.depthClearValue = n.depthClearValue ?? 1)) : s && u && (c.depthReadOnly = !0);
-			for (let e in n) e !== "texture" && e !== "viewDescriptor" && e !== "stencilLoadOp" && e !== "stencilStoreOp" && e !== "stencilClearValue" && e !== "stencilReadOnly" && e !== "depthLoadOp" && e !== "depthStoreOp" && e !== "depthClearValue" && e !== "depthReadOnly" && (c[e] = n[e]);
-		}
-		return {
-			colorAttachments: s,
-			depthStencilAttachment: c,
-			label: e.label
-		};
-	}
-	clear(e, t = !0, n, r, i = 0, a = 0) {
-		if (!t) return;
-		let { gpu: o, encoder: s } = this._renderer, c = o.device;
-		if (s.commandEncoder === null) {
-			let o = c.createCommandEncoder(), s = this.getDescriptor(e, t, n, i, a), l = o.beginRenderPass(s);
-			l.setViewport(r.x, r.y, r.width, r.height, 0, 1), l.end();
-			let u = o.finish();
-			c.queue.submit([u]);
-		} else this.startRenderPass(e, t, n, r, i, a);
-	}
-	initGpuRenderTarget(e) {
-		e.isRoot = !0;
-		let t = new Ee();
-		return e.colorAttachments.forEach((e, n) => {
-			let i = e.texture;
-			if (i instanceof _) {
-				if (!i._gpuContext) {
-					let e = i.resource.getContext("webgpu"), t = i.transparent ? "premultiplied" : "opaque", n = Oe(i.format);
-					try {
-						e.configure({
-							device: this._renderer.gpu.device,
-							usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
-							format: n,
-							alphaMode: t,
-							...n === "rgba16float" ? { toneMapping: { mode: "extended" } } : {}
-						});
-					} catch (e) {
-						console.error(e);
-					}
-					i._gpuContext = e;
-				}
-				t.contexts[n] = i._gpuContext;
-			}
-			if (t.msaa = i.source.antialias, i.antialias) {
-				let e = new r({
-					width: 0,
-					height: 0,
-					sampleCount: 4,
-					transient: i.transient,
-					arrayLayerCount: i.arrayLayerCount,
-					format: i.format
-				});
-				t.msaaTextures[n] = e;
-			}
-		}), t.msaa && (t.msaaSamples = 4, e.depthStencilAttachment && (e.depthStencilAttachment.texture.sampleCount = 4, e.depthStencilAttachment.texture.transient = !!t.msaaTextures[0]?.transient)), t;
-	}
-	destroyGpuRenderTarget(e) {
-		e.contexts.forEach((e) => {
-			e.unconfigure();
-		}), e.msaaTextures.forEach((e) => {
-			e.destroy();
-		}), e.msaaTextures.length = 0, e.contexts.length = 0;
-	}
-	ensureDepthStencilTexture(e) {
-		let t = this._renderTargetSystem.getGpuRenderTarget(e);
-		e.depthStencilAttachment && t.msaa && (e.depthStencilAttachment.texture.sampleCount = 4);
-	}
-	resizeGpuRenderTarget(e) {
-		let t = this._renderTargetSystem.getGpuRenderTarget(e);
-		t.width = e.width, t.height = e.height, t.msaa && e.colorAttachments.forEach((e, n) => {
-			let r = e.texture;
-			t.msaaTextures[n]?.resize(r.width, r.height, r._resolution);
-		});
-	}
-}, W = class extends oe {
-	constructor(e) {
-		super(e), this.adaptor = new ke(), this.adaptor.init(e, this);
-	}
-};
-W.extension = {
-	type: [m.WebGPUSystem],
-	name: "renderTarget"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/shader/GpuShaderSystem.mjs
-var G = class {
-	constructor() {
-		this._gpuProgramData = /* @__PURE__ */ Object.create(null);
-	}
-	contextChange(e) {
-		this._gpu = e;
-	}
-	getProgramData(e) {
-		return this._gpuProgramData[e._layoutKey] || this._createGPUProgramData(e);
-	}
-	_createGPUProgramData(e) {
-		let t = this._gpu.device, n = e.gpuLayout.map((e) => t.createBindGroupLayout({ entries: e })), r = { bindGroupLayouts: n };
-		return this._gpuProgramData[e._layoutKey] = {
-			bindGroups: n,
-			pipeline: t.createPipelineLayout(r)
-		}, this._gpuProgramData[e._layoutKey];
-	}
-	destroy() {
-		this._gpu = null, this._gpuProgramData = null;
-	}
-};
-G.extension = {
-	type: [m.WebGPUSystem],
-	name: "shader"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/state/GpuBlendModesToPixi.mjs
-var K = {};
-K.normal = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	}
-}, K.add = {
-	alpha: {
-		srcFactor: "src-alpha",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "one",
-		dstFactor: "one",
-		operation: "add"
-	}
-}, K.multiply = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "dst",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	}
-}, K.screen = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src",
-		operation: "add"
-	}
-}, K.overlay = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src",
-		operation: "add"
-	}
-}, K.none = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "zero",
-		dstFactor: "zero",
-		operation: "add"
-	}
-}, K["normal-npm"] = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "src-alpha",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	}
-}, K["add-npm"] = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "src-alpha",
-		dstFactor: "one",
-		operation: "add"
-	}
-}, K["screen-npm"] = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "src-alpha",
-		dstFactor: "one-minus-src",
-		operation: "add"
-	}
-}, K.erase = {
-	alpha: {
-		srcFactor: "zero",
-		dstFactor: "one-minus-src-alpha",
-		operation: "add"
-	},
-	color: {
-		srcFactor: "zero",
-		dstFactor: "one-minus-src",
-		operation: "add"
-	}
-}, K.min = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one",
-		operation: "min"
-	},
-	color: {
-		srcFactor: "one",
-		dstFactor: "one",
-		operation: "min"
-	}
-}, K.max = {
-	alpha: {
-		srcFactor: "one",
-		dstFactor: "one",
-		operation: "max"
-	},
-	color: {
-		srcFactor: "one",
-		dstFactor: "one",
-		operation: "max"
-	}
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/state/GpuStateSystem.mjs
-var q = class {
-	constructor() {
-		this.defaultState = new f(), this.defaultState.blend = !0;
-	}
-	contextChange(e) {
-		this.gpu = e;
-	}
-	getColorTargets(e, t, n) {
-		let r = e.blend ? K[e.blendMode] || K.normal : void 0, i = [];
-		for (let e = 0; e < t; e++) i[e] = {
-			format: n,
-			writeMask: 0,
-			blend: r
-		};
-		return i;
-	}
-	destroy() {
-		this.gpu = null;
-	}
-};
-q.extension = {
-	type: [m.WebGPUSystem],
-	name: "state"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/texture/uploaders/gpuUploadBufferImageResource.mjs
-var Ae = {
-	type: "image",
-	upload(e, t, n, r = 0) {
-		let i = e.resource, a = (e.pixelWidth | 0) * (e.pixelHeight | 0), o = i.byteLength / a;
-		n.device.queue.writeTexture({
-			texture: t,
-			origin: {
-				x: 0,
-				y: 0,
-				z: r
-			}
-		}, i, {
-			offset: 0,
-			rowsPerImage: e.pixelHeight,
-			bytesPerRow: e.pixelWidth * o
-		}, {
-			width: e.pixelWidth,
-			height: e.pixelHeight,
-			depthOrArrayLayers: 1
-		});
-	}
-}, J = {
-	"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
-	},
-	"bc7-rgba-unorm": {
-		blockBytes: 16,
-		blockWidth: 4,
-		blockHeight: 4
-	},
-	"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
-	}
-}, je = {
-	blockBytes: 4,
-	blockWidth: 1,
-	blockHeight: 1
-}, Me = {
-	type: "compressed",
-	upload(e, t, n, r = 0) {
-		let i = e.pixelWidth, a = e.pixelHeight, o = J[e.format] || je;
-		for (let s = 0; s < e.resource.length; s++) {
-			let c = e.resource[s], l = Math.ceil(i / o.blockWidth) * o.blockBytes;
-			n.device.queue.writeTexture({
-				texture: t,
-				mipLevel: s,
-				origin: {
-					x: 0,
-					y: 0,
-					z: r
-				}
-			}, c, {
-				offset: 0,
-				bytesPerRow: l
-			}, {
-				width: Math.ceil(i / o.blockWidth) * o.blockWidth,
-				height: Math.ceil(a / o.blockHeight) * o.blockHeight,
-				depthOrArrayLayers: 1
-			}), i = Math.max(i >> 1, 1), a = Math.max(a >> 1, 1);
-		}
-	}
-}, Y = [
-	"right",
-	"left",
-	"top",
-	"bottom",
-	"front",
-	"back"
-];
-function Ne(e) {
-	return {
-		type: "cube",
-		upload(t, n, r) {
-			let i = t.faces;
-			for (let t = 0; t < Y.length; t++) {
-				let a = i[Y[t]];
-				(e[a.uploadMethodId] || e.image).upload(a, n, r, t);
-			}
-		}
-	};
-}
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/texture/uploaders/gpuUploadImageSource.mjs
-var X = {
-	type: "image",
-	upload(e, n, r, a = 0) {
-		let o = e.resource;
-		if (!o) return;
-		if (globalThis.HTMLImageElement && o instanceof HTMLImageElement) {
-			let n = i.get().createCanvas(o.width, o.height);
-			n.getContext("2d").drawImage(o, 0, 0, o.width, o.height), e.resource = n, t("ImageSource: Image element passed, converting to canvas and replacing resource.");
-		}
-		let s = Math.min(n.width, e.resourceWidth || e.pixelWidth), c = Math.min(n.height, e.resourceHeight || e.pixelHeight), l = e.alphaMode === "premultiply-alpha-on-upload";
-		r.device.queue.copyExternalImageToTexture({ source: o }, {
-			texture: n,
-			origin: {
-				x: 0,
-				y: 0,
-				z: a
-			},
-			premultipliedAlpha: l
-		}, {
-			width: s,
-			height: c
-		});
-	}
-}, Pe = {
-	type: "video",
-	upload(e, t, n, r) {
-		X.upload(e, t, n, r);
-	}
-}, Fe = class {
-	constructor(e) {
-		this.device = e, this.sampler = e.createSampler({ minFilter: "linear" }), this.pipelines = {};
-	}
-	_getMipmapPipeline(e) {
-		let t = this.pipelines[e];
-		return t || (this.mipmapShaderModule ||= this.device.createShaderModule({ code: "\n                        var<private> pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(\n                        vec2<f32>(-1.0, -1.0), vec2<f32>(-1.0, 3.0), vec2<f32>(3.0, -1.0));\n\n                        struct VertexOutput {\n                        @builtin(position) position : vec4<f32>,\n                        @location(0) texCoord : vec2<f32>,\n                        };\n\n                        @vertex\n                        fn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput {\n                        var output : VertexOutput;\n                        output.texCoord = pos[vertexIndex] * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5);\n                        output.position = vec4<f32>(pos[vertexIndex], 0.0, 1.0);\n                        return output;\n                        }\n\n                        @group(0) @binding(0) var imgSampler : sampler;\n                        @group(0) @binding(1) var img : texture_2d<f32>;\n\n                        @fragment\n                        fn fragmentMain(@location(0) texCoord : vec2<f32>) -> @location(0) vec4<f32> {\n                        return textureSample(img, imgSampler, texCoord);\n                        }\n                    " }), t = this.device.createRenderPipeline({
-			layout: "auto",
-			vertex: {
-				module: this.mipmapShaderModule,
-				entryPoint: "vertexMain"
-			},
-			fragment: {
-				module: this.mipmapShaderModule,
-				entryPoint: "fragmentMain",
-				targets: [{ format: e }]
-			}
-		}), this.pipelines[e] = t), t;
-	}
-	generateMipmap(e) {
-		let t = this._getMipmapPipeline(e.format);
-		if (e.dimension === "3d" || e.dimension === "1d") throw Error("Generating mipmaps for non-2d textures is currently unsupported!");
-		let n = e, r = e.depthOrArrayLayers || 1, i = e.usage & GPUTextureUsage.RENDER_ATTACHMENT;
-		if (!i) {
-			let t = {
-				size: {
-					width: Math.ceil(e.width / 2),
-					height: Math.ceil(e.height / 2),
-					depthOrArrayLayers: r
-				},
-				format: e.format,
-				usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
-				mipLevelCount: e.mipLevelCount - 1
-			};
-			n = this.device.createTexture(t);
-		}
-		let a = this.device.createCommandEncoder({}), o = t.getBindGroupLayout(0);
-		for (let s = 0; s < r; ++s) {
-			let r = e.createView({
-				baseMipLevel: 0,
-				mipLevelCount: 1,
-				dimension: "2d",
-				baseArrayLayer: s,
-				arrayLayerCount: 1
-			}), c = +!!i;
-			for (let i = 1; i < e.mipLevelCount; ++i) {
-				let e = n.createView({
-					baseMipLevel: c++,
-					mipLevelCount: 1,
-					dimension: "2d",
-					baseArrayLayer: s,
-					arrayLayerCount: 1
-				}), i = a.beginRenderPass({ colorAttachments: [{
-					view: e,
-					storeOp: "store",
-					loadOp: "clear",
-					clearValue: {
-						r: 0,
-						g: 0,
-						b: 0,
-						a: 0
-					}
-				}] }), l = this.device.createBindGroup({
-					layout: o,
-					entries: [{
-						binding: 0,
-						resource: this.sampler
-					}, {
-						binding: 1,
-						resource: r
-					}]
-				});
-				i.setPipeline(t), i.setBindGroup(0, l), i.draw(3, 1, 0, 0), i.end(), r = e;
-			}
-		}
-		if (!i) {
-			let t = {
-				width: Math.ceil(e.width / 2),
-				height: Math.ceil(e.height / 2),
-				depthOrArrayLayers: r
-			};
-			for (let r = 1; r < e.mipLevelCount; ++r) a.copyTextureToTexture({
-				texture: n,
-				mipLevel: r - 1
-			}, {
-				texture: e,
-				mipLevel: r
-			}, t), t.width = Math.ceil(t.width / 2), t.height = Math.ceil(t.height / 2);
-		}
-		return this.device.queue.submit([a.finish()]), i || n.destroy(), e;
-	}
-}, Ie = class {
-	constructor(e) {
-		this.textureView = null, this.textureViews = /* @__PURE__ */ Object.create(null), this.gpuTexture = e;
-	}
-	destroy() {
-		this.gpuTexture.destroy(), this.textureView = null, this.textureViews = null, this.gpuTexture = null;
-	}
-};
-function Z(e) {
-	return `${e.format || ""}.${e.dimension || ""}.${e.aspect || ""}.${e.baseMipLevel || 0}.${e.mipLevelCount || ""}.${e.baseArrayLayer || 0}.${e.arrayLayerCount || ""}`;
-}
-var Q = class e {
-	constructor(t) {
-		this._gpuSamplers = /* @__PURE__ */ Object.create(null), this._bindGroupHash = /* @__PURE__ */ Object.create(null), this._renderer = t, t.gc.addCollection(this, "_bindGroupHash", "hash"), this._managedTextures = new y({
-			renderer: t,
-			type: "resource",
-			onUnload: this.onSourceUnload.bind(this),
-			name: "gpuTextureSource"
-		});
-		let n = {
-			image: X,
-			buffer: Ae,
-			video: Pe,
-			compressed: Me,
-			...e.uploadExtensions
-		};
-		this._uploads = {
-			...n,
-			cube: Ne(n)
-		};
-	}
-	get managedTextures() {
-		return Object.values(this._managedTextures.items);
-	}
-	contextChange(e) {
-		this._gpu = e;
-	}
-	initSource(e) {
-		return e._gpuData[this._renderer.uid]?.gpuTexture || this._initSource(e);
-	}
-	_initSource(e) {
-		if (e.autoGenerateMipmaps) {
-			let t = Math.max(e.pixelWidth, e.pixelHeight);
-			e.mipLevelCount = Math.floor(Math.log2(t)) + 1;
-		}
-		let t;
-		e.sampleCount > 1 ? (t = GPUTextureUsage.RENDER_ATTACHMENT, e.transient && this._renderer.device.extensions.transientAttachment && (t |= GPUTextureUsage.TRANSIENT_ATTACHMENT)) : (t = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST, e.uploadMethodId !== "compressed" && (t |= GPUTextureUsage.RENDER_ATTACHMENT, t |= GPUTextureUsage.COPY_SRC));
-		let n = J[e.format] || {
-			blockBytes: 4,
-			blockWidth: 1,
-			blockHeight: 1
-		}, r = Math.ceil(e.pixelWidth / n.blockWidth) * n.blockWidth, i = Math.ceil(e.pixelHeight / n.blockHeight) * n.blockHeight, a = {
-			label: e.label,
-			size: {
-				width: r,
-				height: i,
-				depthOrArrayLayers: e.arrayLayerCount
-			},
-			format: e.format,
-			sampleCount: e.sampleCount,
-			mipLevelCount: e.mipLevelCount,
-			dimension: e.dimension,
-			usage: t
-		}, o = this._gpu.device.createTexture(a);
-		return e._gpuData[this._renderer.uid] = new Ie(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) {
-		let 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 ||= new Fe(this._gpu.device);
-		let t = this.getGpuSource(e);
-		this._mipmapGenerator.generateMipmap(t);
-	}
-	onSourceUnload(e) {
-		e.off("update", this.onSourceUpdate, this), e.off("resize", this.onSourceResize, this), e.off("updateMipmaps", this.onUpdateMipmaps, this);
-	}
-	onSourceResize(e) {
-		e._gcLastUsed = this._renderer.gc.now;
-		let t = e._gpuData[this._renderer.uid], n = t?.gpuTexture;
-		n ? (n.width !== e.pixelWidth || n.height !== e.pixelHeight) && (t.destroy(), this._bindGroupHash[e.uid] = null, e._gpuData[this._renderer.uid] = null, this.initSource(e)) : this.initSource(e);
-	}
-	_initSampler(e) {
-		return this._gpuSamplers[e._resourceId] = this._gpu.device.createSampler(e), this._gpuSamplers[e._resourceId];
-	}
-	getGpuSampler(e) {
-		return this._gpuSamplers[e._resourceId] || this._initSampler(e);
-	}
-	getGpuSource(e) {
-		return e._gcLastUsed = this._renderer.gc.now, e._gpuData[this._renderer.uid]?.gpuTexture || this.initSource(e);
-	}
-	getTextureBindGroup(e) {
-		return this._bindGroupHash[e.uid] || this._createTextureBindGroup(e);
-	}
-	_createTextureBindGroup(e) {
-		let t = e.source;
-		return this._bindGroupHash[e.uid] = new g({
-			0: t,
-			1: t.style,
-			2: new o({ uTextureMatrix: {
-				type: "mat3x3<f32>",
-				value: e.textureMatrix.mapCoord
-			} })
-		}), this._bindGroupHash[e.uid];
-	}
-	getTextureView(e, t) {
-		var n;
-		let r = e.source;
-		r._gcLastUsed = this._renderer.gc.now;
-		let i = r._gpuData[this._renderer.uid];
-		i ||= (this.initSource(r), r._gpuData[this._renderer.uid]);
-		let a = t ? Z(t) : 0;
-		return (n = i.textureViews)[a] || (n[a] = i.gpuTexture.createView({
-			dimension: r.viewDimension,
-			...t
-		})), i.textureViews[a];
-	}
-	getTextureRenderTargetView(e, t = 0, n = 0, r) {
-		var i;
-		let a = e.source;
-		a._gcLastUsed = this._renderer.gc.now;
-		let o = a._gpuData[this._renderer.uid];
-		o ||= (this.initSource(a), a._gpuData[this._renderer.uid]);
-		let s = n * (a.mipLevelCount || 1) + t + 1;
-		return r && (s = `${s}.${Z(r)}`), (i = o.textureViews)[s] || (i[s] = o.gpuTexture.createView({
-			dimension: "2d",
-			baseMipLevel: t,
-			mipLevelCount: 1,
-			baseArrayLayer: n,
-			arrayLayerCount: 1,
-			...r
-		})), o.textureViews[s];
-	}
-	generateCanvas(e) {
-		let t = this._renderer, n = t.gpu.device.createCommandEncoder(), r = i.get().createCanvas();
-		r.width = e.source.pixelWidth, r.height = e.source.pixelHeight;
-		let a = r.getContext("webgpu");
-		return a.configure({
-			device: t.gpu.device,
-			usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
-			format: i.get().getNavigator().gpu.getPreferredCanvasFormat(),
-			alphaMode: "premultiplied"
-		}), n.copyTextureToTexture({
-			texture: t.texture.getGpuSource(e.source),
-			origin: {
-				x: 0,
-				y: 0
-			}
-		}, { texture: a.getCurrentTexture() }, {
-			width: r.width,
-			height: r.height
-		}), t.gpu.device.queue.submit([n.finish()]), r;
-	}
-	getPixels(e) {
-		let t = this.generateCanvas(e), n = C.getOptimalCanvasAndContext(t.width, t.height), r = n.context;
-		r.drawImage(t, 0, 0);
-		let { width: i, height: a } = t, o = r.getImageData(0, 0, i, a), s = new Uint8ClampedArray(o.data.buffer);
-		return C.returnCanvasAndContext(n), {
-			pixels: s,
-			width: i,
-			height: a
-		};
-	}
-	destroy() {
-		this._managedTextures.destroy();
-		for (let e of Object.keys(this._bindGroupHash)) {
-			let t = Number(e);
-			this._bindGroupHash[t]?.destroy();
-		}
-		this._renderer = null, this._gpu = null, this._mipmapGenerator = null, this._gpuSamplers = null, this._bindGroupHash = null;
-	}
-};
-Q.extension = {
-	type: [m.WebGPUSystem],
-	name: "texture"
-}, Q.uploadExtensions = /* @__PURE__ */ Object.create(null);
-var Le = Q;
-l.handleByMap(m.TextureUploaderWebGPU, Le.uploadExtensions);
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/scene/graphics/gpu/GpuGraphicsAdaptor.mjs
-var Re = class {
-	constructor() {
-		this._maxTextures = 0;
-	}
-	contextChange(e) {
-		let t = new o({
-			uTransformMatrix: {
-				value: new s(),
-				type: "mat3x3<f32>"
-			},
-			uColor: {
-				value: new Float32Array([
-					1,
-					1,
-					1,
-					1
-				]),
-				type: "vec4<f32>"
-			},
-			uRound: {
-				value: 0,
-				type: "f32"
-			}
-		});
-		this._maxTextures = e.limits.maxBatchableTextures;
-		let n = x({
-			name: "graphics",
-			bits: [
-				se,
-				ne(this._maxTextures),
-				fe,
-				re
-			]
-		});
-		this.shader = new h({
-			gpuProgram: n,
-			resources: { localUniforms: t }
-		});
-	}
-	execute(e, t) {
-		let n = t.context, r = n.customShader || this.shader, i = e.renderer, { batcher: a, instructions: o } = i.graphicsContext.getContextRenderData(n), s = i.encoder;
-		s.setGeometry(a.geometry, r.gpuProgram);
-		let c = i.globalUniforms.bindGroup;
-		s.setBindGroup(0, c, r.gpuProgram);
-		let l = i.renderPipes.uniformBatch.getUniformBindGroup(r.resources.localUniforms, !0);
-		s.setBindGroup(2, l, r.gpuProgram);
-		let u = o.instructions, d = null;
-		for (let t = 0; t < o.instructionSize; t++) {
-			let n = u[t];
-			if (n.topology !== d && (d = n.topology, s.setPipelineFromGeometryProgramAndState(a.geometry, r.gpuProgram, e.state, n.topology, r._overrides)), r.groups[1] = n.bindGroup, !n.gpuBindGroup) {
-				let e = n.textures;
-				n.bindGroup = S(e.textures, e.count, this._maxTextures), n.gpuBindGroup = i.bindGroup.getBindGroup(n.bindGroup, r.gpuProgram, 1);
-			}
-			s.setBindGroup(1, n.bindGroup, r.gpuProgram), s.renderPassEncoder.drawIndexed(n.size, 1, n.start);
-		}
-	}
-	destroy() {
-		this.shader.destroy(!0), this.shader = null;
-	}
-};
-Re.extension = {
-	type: [m.WebGPUPipesAdaptor],
-	name: "graphics"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/scene/mesh/gpu/GpuMeshAdapter.mjs
-var ze = class {
-	init() {
-		let e = x({
-			name: "mesh",
-			bits: [
-				ce,
-				ue,
-				re
-			]
-		});
-		this._shader = new h({
-			gpuProgram: e,
-			resources: {
-				uTexture: n.EMPTY._source,
-				uSampler: n.EMPTY._source.style,
-				textureUniforms: { uTextureMatrix: {
-					type: "mat3x3<f32>",
-					value: new s()
-				} }
-			}
-		});
-	}
-	execute(e, n) {
-		let r = e.renderer, i = n._shader;
-		if (!i) i = this._shader, i.groups[2] = r.texture.getTextureBindGroup(n.texture);
-		else if (!i.gpuProgram) {
-			t("Mesh shader has no gpuProgram", n.shader);
-			return;
-		}
-		let a = i.gpuProgram;
-		if (a.autoAssignGlobalUniforms && (i.groups[0] = r.globalUniforms.bindGroup), a.autoAssignLocalUniforms) {
-			let t = e.localUniforms;
-			i.groups[1] = r.renderPipes.uniformBatch.getUniformBindGroup(t, !0);
-		}
-		r.encoder.draw({
-			geometry: n._geometry,
-			shader: i,
-			state: n.state
-		});
-	}
-	destroy() {
-		this._shader.destroy(!0), this._shader = null;
-	}
-};
-ze.extension = {
-	type: [m.WebGPUPipesAdaptor],
-	name: "mesh"
-};
-//#endregion
-//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gpu/WebGPURenderer.mjs
-var Be = /* @__PURE__ */ e({ WebGPURenderer: () => Ke }), Ve = [
-	...ae,
-	F,
-	j,
-	A,
-	M,
-	O,
-	Le,
-	W,
-	G,
-	q,
-	U,
-	k,
-	N,
-	D
-], He = [...ie, L], Ue = [
-	E,
-	ze,
-	Re
-], We = [], Ge = [], $ = [];
-l.handleByNamedList(m.WebGPUSystem, We), l.handleByNamedList(m.WebGPUPipes, Ge), l.handleByNamedList(m.WebGPUPipesAdaptor, $), l.add(...Ve, ...He, ...Ue);
-var Ke = class extends ee {
-	constructor() {
-		let e = {
-			name: "webgpu",
-			type: u.WEBGPU,
-			systems: We,
-			renderPipes: Ge,
-			renderPipeAdaptors: $
-		};
-		super(e);
-	}
-};
-//#endregion
-export { Be as t };