@number10/phaserjsx 4.1.0 → 4.2.0

package/dist/clip-CHmjztBQ.cjs

@@ -0,0 +1,705 @@
+const require_chunk = require("./chunk-C2EiDwsr.cjs");
+let phaser = require("phaser");
+phaser = require_chunk.__toESM(phaser, 1);
+//#region src/clip/stencil-clip-depth.ts
+/**
+* Shared depth counter per GL context.
+* Incremented before each clip's INCR pass, decremented after the DECR pass.
+*/
+var _depthByGl = /* @__PURE__ */ new WeakMap();
+var _prerenderHooked = /* @__PURE__ */ new WeakSet();
+function getDepth(gl) {
+	let d = _depthByGl.get(gl);
+	if (!d) {
+		d = { value: 0 };
+		_depthByGl.set(gl, d);
+	}
+	return d;
+}
+/**
+* Registers a per-frame prerender listener that resets stencil clip state.
+* Registered at most once per Phaser.Game instance.
+*/
+function ensurePrerenderReset(gl, game, resetFboState) {
+	if (_prerenderHooked.has(game)) return;
+	_prerenderHooked.add(game);
+	game.events.on("prerender", () => {
+		const d = _depthByGl.get(gl);
+		if (d) d.value = 0;
+		resetFboState(gl);
+	});
+}
+//#endregion
+//#region src/clip/stencil-clip-fbo-bridge.ts
+var _fboPatchByGl = /* @__PURE__ */ new WeakMap();
+function resetFboPatchState(gl) {
+	const fbo = _fboPatchByGl.get(gl);
+	if (fbo) {
+		fbo.current = null;
+		fbo.saved = null;
+	}
+}
+/**
+* Patches gl.bindFramebuffer once per GL context so that the stencil test is
+* disabled while Phaser renders PostFX / RenderTextures into off-screen FBOs.
+*/
+function ensureFboPatch(gl) {
+	if (_fboPatchByGl.has(gl)) return;
+	const state = {
+		current: null,
+		saved: null
+	};
+	_fboPatchByGl.set(gl, state);
+	const origBind = gl.bindFramebuffer.bind(gl);
+	gl.bindFramebuffer = (target, fb) => {
+		const wasMain = state.current === null;
+		const willBeMain = fb === null;
+		const enteringOffscreen = wasMain && !willBeMain;
+		const leavingOffscreen = !wasMain && willBeMain;
+		if (enteringOffscreen && gl.getParameter(gl.STENCIL_TEST)) {
+			state.saved = {
+				func: gl.getParameter(gl.STENCIL_FUNC),
+				ref: gl.getParameter(gl.STENCIL_REF),
+				valueMask: gl.getParameter(gl.STENCIL_VALUE_MASK),
+				fail: gl.getParameter(gl.STENCIL_FAIL),
+				zfail: gl.getParameter(gl.STENCIL_PASS_DEPTH_FAIL),
+				zpass: gl.getParameter(gl.STENCIL_PASS_DEPTH_PASS),
+				writeMask: gl.getParameter(gl.STENCIL_WRITEMASK)
+			};
+			gl.disable(gl.STENCIL_TEST);
+		}
+		origBind(target, fb);
+		state.current = fb;
+		if (leavingOffscreen && state.saved) {
+			gl.enable(gl.STENCIL_TEST);
+			gl.stencilFunc(state.saved.func, state.saved.ref, state.saved.valueMask);
+			gl.stencilOp(state.saved.fail, state.saved.zfail, state.saved.zpass);
+			gl.stencilMask(state.saved.writeMask);
+			state.saved = null;
+		}
+	};
+}
+//#endregion
+//#region src/clip/stencil-clip-renderer.ts
+function savePhaserGLState(renderer) {
+	const glWrapper = renderer.glWrapper;
+	return {
+		activeTexture: glWrapper.state?.bindings?.activeTexture,
+		arrayBuffer: glWrapper.state?.bindings?.arrayBuffer ?? null,
+		program: glWrapper.state?.bindings?.program ?? null,
+		vao: glWrapper.state?.vao ?? null
+	};
+}
+function restorePhaserGLState(renderer, saved, fallbackActiveTexture) {
+	const glWrapper = renderer.glWrapper;
+	if (glWrapper.update) {
+		glWrapper.update({
+			bindings: {
+				activeTexture: saved.activeTexture ?? fallbackActiveTexture,
+				arrayBuffer: saved.arrayBuffer,
+				program: saved.program
+			},
+			vao: saved.vao
+		}, true);
+		return;
+	}
+	glWrapper.updateBindingsActiveTexture?.({ bindings: { activeTexture: saved.activeTexture ?? fallbackActiveTexture } }, true);
+}
+var ROUND_RECT_VERT_SRC = `
+attribute vec2 a_ndc;
+attribute vec2 a_loc;
+varying vec2 v_loc;
+void main(){gl_Position=vec4(a_ndc,0.,1.);v_loc=a_loc;}
+`;
+var ROUND_RECT_FRAG_SRC = `
+precision mediump float;
+varying vec2 v_loc;
+uniform vec2 u_halfSize;
+uniform vec4 u_radii;
+float sdRoundedBox(vec2 p,vec2 b,vec4 r){
+  r.xy=p.x>0.?r.yz:r.xw;
+  r.x =p.y>0.?r.y :r.x;
+  vec2 q=abs(p)-b+r.x;
+  return length(max(q,0.))+min(max(q.x,q.y),0.)-r.x;
+}
+void main(){
+  if(sdRoundedBox(v_loc,u_halfSize,u_radii)>0.)discard;
+  gl_FragColor=vec4(0.);
+}
+`;
+var BITMAP_VERT_SRC = `
+attribute vec2 a_ndc;
+attribute vec2 a_uv;
+varying vec2 v_uv;
+void main(){gl_Position=vec4(a_ndc,0.,1.);v_uv=a_uv;}
+`;
+var BITMAP_FRAG_SRC = `
+precision mediump float;
+varying vec2 v_uv;
+uniform sampler2D u_texture;
+uniform float u_alphaThreshold;
+uniform float u_invertAlpha;
+void main(){
+  float a=texture2D(u_texture,v_uv).a;
+  bool keep=u_invertAlpha>0.5 ? a<u_alphaThreshold : a>=u_alphaThreshold;
+  if(!keep)discard;
+  gl_FragColor=vec4(0.);
+}
+`;
+var _roundRectProgByGl = /* @__PURE__ */ new WeakMap();
+var _bitmapProgByGl = /* @__PURE__ */ new WeakMap();
+function createProgram(gl, vertSrc, fragSrc) {
+	const vs = gl.createShader(gl.VERTEX_SHADER);
+	gl.shaderSource(vs, vertSrc);
+	gl.compileShader(vs);
+	const fs = gl.createShader(gl.FRAGMENT_SHADER);
+	gl.shaderSource(fs, fragSrc);
+	gl.compileShader(fs);
+	const prog = gl.createProgram();
+	gl.attachShader(prog, vs);
+	gl.attachShader(prog, fs);
+	gl.linkProgram(prog);
+	return prog;
+}
+function getRoundRectProg(gl) {
+	let prog = _roundRectProgByGl.get(gl);
+	if (prog) return prog;
+	prog = createProgram(gl, ROUND_RECT_VERT_SRC, ROUND_RECT_FRAG_SRC);
+	_roundRectProgByGl.set(gl, prog);
+	return prog;
+}
+function getBitmapProg(gl) {
+	let prog = _bitmapProgByGl.get(gl);
+	if (prog) return prog;
+	prog = createProgram(gl, BITMAP_VERT_SRC, BITMAP_FRAG_SRC);
+	_bitmapProgByGl.set(gl, prog);
+	return prog;
+}
+var _roundRectLocsByProg = /* @__PURE__ */ new WeakMap();
+var _bitmapLocsByProg = /* @__PURE__ */ new WeakMap();
+function getRoundRectShaderLocs(gl, prog) {
+	let l = _roundRectLocsByProg.get(prog);
+	if (!l) {
+		l = {
+			ndc: gl.getAttribLocation(prog, "a_ndc"),
+			loc: gl.getAttribLocation(prog, "a_loc"),
+			halfSize: gl.getUniformLocation(prog, "u_halfSize"),
+			radii: gl.getUniformLocation(prog, "u_radii")
+		};
+		_roundRectLocsByProg.set(prog, l);
+	}
+	return l;
+}
+function getBitmapShaderLocs(gl, prog) {
+	let l = _bitmapLocsByProg.get(prog);
+	if (!l) {
+		l = {
+			ndc: gl.getAttribLocation(prog, "a_ndc"),
+			uv: gl.getAttribLocation(prog, "a_uv"),
+			texture: gl.getUniformLocation(prog, "u_texture"),
+			alphaThreshold: gl.getUniformLocation(prog, "u_alphaThreshold"),
+			invertAlpha: gl.getUniformLocation(prog, "u_invertAlpha")
+		};
+		_bitmapLocsByProg.set(prog, l);
+	}
+	return l;
+}
+var STRIDE = 16;
+function drawRoundRectMaskShape(gl, scene, matrix, cameraMatrix, offsetX, offsetY, w, h, logW, logH, radii, vertBuf, verts) {
+	const { a, b, c, d, tx, ty } = matrix;
+	const hw = w / 2;
+	const hh = h / 2;
+	const cx = offsetX + hw;
+	const cy = offsetY + hh;
+	const corners = [
+		[cx - hw, cy - hh],
+		[cx + hw, cy - hh],
+		[cx + hw, cy + hh],
+		[cx - hw, cy + hh]
+	];
+	for (let i = 0; i < 4; i++) {
+		const corner = corners[i];
+		const lx = corner[0];
+		const ly = corner[1];
+		const wx = a * lx + c * ly + tx;
+		const wy = b * lx + d * ly + ty;
+		const sx = cameraMatrix ? cameraMatrix.getX(wx, wy) : wx;
+		const sy = cameraMatrix ? cameraMatrix.getY(wx, wy) : wy;
+		verts[i * 4 + 0] = sx / logW * 2 - 1;
+		verts[i * 4 + 1] = 1 - sy / logH * 2;
+		verts[i * 4 + 2] = lx - cx;
+		verts[i * 4 + 3] = ly - cy;
+	}
+	const prevProg = gl.getParameter(gl.CURRENT_PROGRAM);
+	const prevBuf = gl.getParameter(gl.ARRAY_BUFFER_BINDING);
+	const prevVAO = gl.getParameter(34229);
+	const prevActiveTextureUnit = gl.getParameter(gl.ACTIVE_TEXTURE) - gl.TEXTURE0;
+	const renderer = scene.renderer;
+	const savedPhaserState = savePhaserGLState(renderer);
+	gl.bindVertexArray(null);
+	gl.bindBuffer(gl.ARRAY_BUFFER, vertBuf);
+	gl.bufferSubData(gl.ARRAY_BUFFER, 0, verts);
+	const prog = getRoundRectProg(gl);
+	gl.useProgram(prog);
+	const locs = getRoundRectShaderLocs(gl, prog);
+	gl.enableVertexAttribArray(locs.ndc);
+	gl.vertexAttribPointer(locs.ndc, 2, gl.FLOAT, false, STRIDE, 0);
+	gl.enableVertexAttribArray(locs.loc);
+	gl.vertexAttribPointer(locs.loc, 2, gl.FLOAT, false, STRIDE, 8);
+	gl.uniform2f(locs.halfSize, hw, hh);
+	gl.uniform4f(locs.radii, radii[0], radii[1], radii[2], radii[3]);
+	gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+	gl.disableVertexAttribArray(locs.ndc);
+	gl.disableVertexAttribArray(locs.loc);
+	gl.bindBuffer(gl.ARRAY_BUFFER, prevBuf);
+	gl.useProgram(prevProg);
+	gl.bindVertexArray(prevVAO);
+	restorePhaserGLState(renderer, savedPhaserState, prevActiveTextureUnit);
+}
+function isTextureFrame(value) {
+	return typeof value === "object" && value !== null && "glTexture" in value && "u0" in value;
+}
+function resolveBitmapFrame(scene, source) {
+	const frame = isTextureFrame(source.texture) ? source.texture : typeof source.texture === "string" ? scene.textures.getFrame(source.texture, source.frame) : source.texture.get(source.frame);
+	if (!frame?.glTexture?.webGLTexture) return null;
+	return {
+		glTexture: frame.glTexture,
+		width: source.width ?? frame.cutWidth ?? frame.realWidth,
+		height: source.height ?? frame.cutHeight ?? frame.realHeight,
+		u0: frame.u0,
+		v0: frame.v0,
+		u1: frame.u1,
+		v1: frame.v1
+	};
+}
+function drawBitmapMaskShape(gl, scene, matrix, cameraMatrix, source, frameInfo, logW, logH, vertBuf, verts) {
+	const { a, b, c, d, tx, ty } = matrix;
+	const x0 = source.offsetX;
+	const y0 = source.offsetY;
+	const x1 = x0 + frameInfo.width;
+	const y1 = y0 + frameInfo.height;
+	const corners = [
+		[
+			x0,
+			y0,
+			frameInfo.u0,
+			frameInfo.v0
+		],
+		[
+			x1,
+			y0,
+			frameInfo.u1,
+			frameInfo.v0
+		],
+		[
+			x1,
+			y1,
+			frameInfo.u1,
+			frameInfo.v1
+		],
+		[
+			x0,
+			y1,
+			frameInfo.u0,
+			frameInfo.v1
+		]
+	];
+	for (let i = 0; i < 4; i++) {
+		const corner = corners[i];
+		const lx = corner[0];
+		const ly = corner[1];
+		const wx = a * lx + c * ly + tx;
+		const wy = b * lx + d * ly + ty;
+		const sx = cameraMatrix ? cameraMatrix.getX(wx, wy) : wx;
+		const sy = cameraMatrix ? cameraMatrix.getY(wx, wy) : wy;
+		verts[i * 4 + 0] = sx / logW * 2 - 1;
+		verts[i * 4 + 1] = 1 - sy / logH * 2;
+		verts[i * 4 + 2] = corner[2];
+		verts[i * 4 + 3] = corner[3];
+	}
+	const prevProg = gl.getParameter(gl.CURRENT_PROGRAM);
+	const prevBuf = gl.getParameter(gl.ARRAY_BUFFER_BINDING);
+	const prevVAO = gl.getParameter(34229);
+	const prevActiveTextureUnit = gl.getParameter(gl.ACTIVE_TEXTURE) - gl.TEXTURE0;
+	const renderer = scene.renderer;
+	const savedPhaserState = savePhaserGLState(renderer);
+	gl.bindVertexArray(null);
+	gl.bindBuffer(gl.ARRAY_BUFFER, vertBuf);
+	gl.bufferSubData(gl.ARRAY_BUFFER, 0, verts);
+	const prog = getBitmapProg(gl);
+	gl.useProgram(prog);
+	const locs = getBitmapShaderLocs(gl, prog);
+	gl.enableVertexAttribArray(locs.ndc);
+	gl.vertexAttribPointer(locs.ndc, 2, gl.FLOAT, false, STRIDE, 0);
+	gl.enableVertexAttribArray(locs.uv);
+	gl.vertexAttribPointer(locs.uv, 2, gl.FLOAT, false, STRIDE, 8);
+	const textureUnits = renderer.glTextureUnits;
+	const prevTexture = textureUnits.units[0] ?? null;
+	textureUnits.bind(frameInfo.glTexture, 0);
+	gl.uniform1i(locs.texture, 0);
+	gl.uniform1f(locs.alphaThreshold, source.alphaThreshold);
+	gl.uniform1f(locs.invertAlpha, source.invertAlpha ? 1 : 0);
+	gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+	gl.disableVertexAttribArray(locs.ndc);
+	gl.disableVertexAttribArray(locs.uv);
+	textureUnits.bind(prevTexture, 0);
+	renderer.glWrapper.updateBindingsActiveTexture({ bindings: { activeTexture: prevActiveTextureUnit } });
+	gl.bindBuffer(gl.ARRAY_BUFFER, prevBuf);
+	gl.useProgram(prevProg);
+	gl.bindVertexArray(prevVAO);
+	restorePhaserGLState(renderer, savedPhaserState, prevActiveTextureUnit);
+}
+function drawMaskShape(gl, scene, matrix, cameraMatrix, source, logW, logH, vertBuf, verts) {
+	if (source.kind === "bitmap") {
+		const frameInfo = resolveBitmapFrame(scene, source);
+		if (!frameInfo) return;
+		drawBitmapMaskShape(gl, scene, matrix, cameraMatrix, source, frameInfo, logW, logH, vertBuf, verts);
+		return;
+	}
+	drawRoundRectMaskShape(gl, scene, matrix, cameraMatrix, source.offsetX, source.offsetY, source.width, source.height, logW, logH, source.radii, vertBuf, verts);
+}
+//#endregion
+//#region src/clip/stencil-clip-state.ts
+function resolveRadii(r) {
+	if (!r) return [
+		0,
+		0,
+		0,
+		0
+	];
+	if (typeof r === "number") return [
+		r,
+		r,
+		r,
+		r
+	];
+	return [
+		r.tl ?? 0,
+		r.tr ?? 0,
+		r.br ?? 0,
+		r.bl ?? 0
+	];
+}
+/** Returns true when a source/update selects the bitmap mask renderer. */
+function isBitmapStencilClipSource(source) {
+	return source.kind === "bitmap";
+}
+function toRoundRectState(source) {
+	return {
+		kind: "roundRect",
+		width: source.width,
+		height: source.height,
+		offsetX: source.offsetX ?? 0,
+		offsetY: source.offsetY ?? 0,
+		radii: source.kind === "rect" ? [
+			0,
+			0,
+			0,
+			0
+		] : resolveRadii(source.cornerRadius)
+	};
+}
+function toBitmapState(source) {
+	return {
+		kind: "bitmap",
+		texture: source.texture,
+		frame: source.frame,
+		width: source.width,
+		height: source.height,
+		offsetX: source.offsetX ?? 0,
+		offsetY: source.offsetY ?? 0,
+		alphaThreshold: source.alphaThreshold ?? .5,
+		invertAlpha: source.invertAlpha ?? false
+	};
+}
+function toMaskState(source) {
+	return isBitmapStencilClipSource(source) ? toBitmapState(source) : toRoundRectState(source);
+}
+function mergeMaskState(current, update) {
+	if (isBitmapStencilClipSource(update)) {
+		if (current.kind !== "bitmap" || update.texture !== void 0) return toBitmapState(update);
+		return {
+			kind: "bitmap",
+			texture: current.texture,
+			frame: update.frame !== void 0 ? update.frame : current.frame,
+			width: update.width !== void 0 ? update.width : current.width,
+			height: update.height !== void 0 ? update.height : current.height,
+			offsetX: update.offsetX !== void 0 ? update.offsetX : current.offsetX,
+			offsetY: update.offsetY !== void 0 ? update.offsetY : current.offsetY,
+			alphaThreshold: update.alphaThreshold !== void 0 ? update.alphaThreshold : current.alphaThreshold,
+			invertAlpha: update.invertAlpha !== void 0 ? update.invertAlpha : current.invertAlpha
+		};
+	}
+	if (current.kind === "bitmap" && update.kind === void 0) {
+		const bitmapUpdate = update;
+		return {
+			kind: "bitmap",
+			texture: current.texture,
+			frame: bitmapUpdate.frame !== void 0 ? bitmapUpdate.frame : current.frame,
+			width: bitmapUpdate.width !== void 0 ? bitmapUpdate.width : current.width,
+			height: bitmapUpdate.height !== void 0 ? bitmapUpdate.height : current.height,
+			offsetX: bitmapUpdate.offsetX !== void 0 ? bitmapUpdate.offsetX : current.offsetX,
+			offsetY: bitmapUpdate.offsetY !== void 0 ? bitmapUpdate.offsetY : current.offsetY,
+			alphaThreshold: bitmapUpdate.alphaThreshold !== void 0 ? bitmapUpdate.alphaThreshold : current.alphaThreshold,
+			invertAlpha: bitmapUpdate.invertAlpha !== void 0 ? bitmapUpdate.invertAlpha : current.invertAlpha
+		};
+	}
+	if (current.kind === "bitmap") return toRoundRectState(update);
+	const roundUpdate = update;
+	return {
+		kind: "roundRect",
+		width: roundUpdate.width !== void 0 ? roundUpdate.width : current.width,
+		height: roundUpdate.height !== void 0 ? roundUpdate.height : current.height,
+		offsetX: roundUpdate.offsetX !== void 0 ? roundUpdate.offsetX : current.offsetX,
+		offsetY: roundUpdate.offsetY !== void 0 ? roundUpdate.offsetY : current.offsetY,
+		radii: roundUpdate.kind === "rect" ? [
+			0,
+			0,
+			0,
+			0
+		] : "cornerRadius" in roundUpdate ? resolveRadii(roundUpdate.cornerRadius) : current.radii
+	};
+}
+//#endregion
+//#region src/clip/stencil-clip.ts
+/**
+* WebGL stencil-buffer clip for Phaser 4 Containers.
+*
+* Supports arbitrary nesting via the INCR/DECR model: each clip level
+* increments the stencil on enter and decrements on exit, so child clips are
+* automatically intersected with their parent clips at the hardware level.
+*
+* Shape variants:
+*   - Plain rectangle   (cornerRadius omitted or 0)
+*   - Rounded rectangle (uniform radius or per-corner object)
+*
+* A single SDF-based shader handles both variants.  For plain rectangles
+* u_radii is vec4(0) and the `discard` branch never fires — no overhead
+* compared to a rectangle-only shader.
+*
+* Transforms (translate, scale, rotation) are fully supported: the quad
+* corners are transformed through `container.getWorldTransformMatrix()` at
+* render time, so no per-layout world-position tracking is needed.
+*/
+var STENCIL_HANDLE = Symbol("stencilClipHandle");
+/** Returns the active stencil clip handle attached to a container, if any. */
+function getStencilClipHandle(container) {
+	return container[STENCIL_HANDLE];
+}
+/** Removes any active stencil clip from a container. */
+function clearStencilClip(container) {
+	getStencilClipHandle(container)?.destroy();
+}
+/**
+* Applies a WebGL stencil-buffer clip to a Phaser 4 Container.
+*
+* The clip rectangle is expressed in the container's **local coordinate
+* space**.  `offsetX`/`offsetY` mark the top-left corner (default 0/0), so
+* a container whose visual area starts at its local origin can be clipped with
+* `applyStencilClip(container, { width, height })`.
+*
+* **Nesting** is handled transparently: each clip level occupies one stencil
+* value (0 = no clip, 1 = depth 0, 2 = depth 1, …).  Child clips are always
+* the intersection of their own shape and all ancestor shapes.
+*
+* **Transforms** (translate, scale, rotation) are re-evaluated from
+* `container.getWorldTransformMatrix()` on every frame, so animated or
+* scroll-driven containers clip correctly without any manual update call.
+*
+* If a stencil clip is already attached to the container, calling this
+* function again calls `handle.update(shape)` on the existing handle and
+* returns it.
+*
+* @param container - The container to clip.
+* @param source - Clip source in the container's local coordinate space.
+* @returns A handle to modify dimensions / corner radii or remove the clip.
+*/
+function applyStencilClip(container, source) {
+	const obj = container;
+	if (obj[STENCIL_HANDLE]) {
+		obj[STENCIL_HANDLE].update(source);
+		return obj[STENCIL_HANDLE];
+	}
+	if (container.scene.renderer.type !== phaser.WEBGL) return {
+		update() {},
+		destroy() {}
+	};
+	const renderer = container.scene.renderer;
+	const gl = renderer.gl;
+	const glWrapper = renderer.glWrapper;
+	ensurePrerenderReset(gl, container.scene.game, resetFboPatchState);
+	ensureFboPatch(gl);
+	const previousArrayBuffer = glWrapper.state?.bindings?.arrayBuffer ?? null;
+	const vertBuf = gl.createBuffer();
+	gl.bindBuffer(gl.ARRAY_BUFFER, vertBuf);
+	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(16), gl.DYNAMIC_DRAW);
+	gl.bindBuffer(gl.ARRAY_BUFFER, null);
+	glWrapper.updateBindingsArrayBuffer?.({ bindings: { arrayBuffer: previousArrayBuffer } }, true);
+	const verts = new Float32Array(16);
+	let maskSource = toMaskState(source);
+	let destroyed = false;
+	const wrapper = (webglRenderer, go, drawingContext, parentMatrix, renderStep = 0, displayList, displayListIndex) => {
+		const renderNext = () => {
+			go.renderWebGLStep(webglRenderer, go, drawingContext, parentMatrix, renderStep + 1, displayList, displayListIndex);
+		};
+		if (destroyed) {
+			renderNext();
+			return;
+		}
+		const matrix = container.getWorldTransformMatrix();
+		const context = drawingContext;
+		const cameraMatrix = context.camera?.getViewMatrix(!context.useCanvas);
+		const rn = webglRenderer.renderNodes;
+		const depth = getDepth(gl);
+		const myDepth = depth.value++;
+		const logW = webglRenderer.width;
+		const logH = webglRenderer.height;
+		rn.finishBatch();
+		if (myDepth === 0) gl.enable(gl.STENCIL_TEST);
+		gl.colorMask(false, false, false, false);
+		gl.stencilMask(255);
+		gl.stencilFunc(gl.EQUAL, myDepth, 255);
+		gl.stencilOp(gl.KEEP, gl.KEEP, gl.INCR);
+		drawMaskShape(gl, container.scene, matrix, cameraMatrix, maskSource, logW, logH, vertBuf, verts);
+		gl.colorMask(true, true, true, true);
+		gl.stencilFunc(gl.EQUAL, myDepth + 1, 255);
+		gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+		gl.stencilMask(0);
+		renderNext();
+		rn.finishBatch();
+		gl.colorMask(false, false, false, false);
+		gl.stencilMask(255);
+		gl.stencilFunc(gl.EQUAL, myDepth + 1, 255);
+		gl.stencilOp(gl.KEEP, gl.KEEP, gl.DECR);
+		drawMaskShape(gl, container.scene, matrix, cameraMatrix, maskSource, logW, logH, vertBuf, verts);
+		gl.colorMask(true, true, true, true);
+		depth.value--;
+		if (myDepth === 0) {
+			gl.disable(gl.STENCIL_TEST);
+			gl.stencilMask(255);
+		} else {
+			gl.stencilFunc(gl.EQUAL, myDepth, 255);
+			gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+			gl.stencilMask(0);
+		}
+	};
+	const handle = {
+		update(s) {
+			maskSource = mergeMaskState(maskSource, s);
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			gl.deleteBuffer(vertBuf);
+			const index = obj._renderSteps.indexOf(wrapper);
+			if (index !== -1) obj._renderSteps.splice(index, 1);
+			delete obj[STENCIL_HANDLE];
+		}
+	};
+	obj.addRenderStep(wrapper, 0);
+	obj[STENCIL_HANDLE] = handle;
+	return handle;
+}
+//#endregion
+//#region src/clip/stencil-clip-extension.ts
+function addMethod(proto, methodName, fn) {
+	const hadOwn = Object.prototype.hasOwnProperty.call(proto, methodName);
+	const previous = proto[methodName];
+	if (!hadOwn) proto[methodName] = fn;
+	return { restore: () => {
+		if (!hadOwn) delete proto[methodName];
+		else proto[methodName] = previous;
+	} };
+}
+function wrapMethod(proto, methodName, wrapper) {
+	const original = proto[methodName];
+	if (typeof original !== "function") return { restore() {} };
+	const wrapped = function(...args) {
+		return wrapper(original, this, ...args);
+	};
+	proto[methodName] = wrapped;
+	return { restore: () => {
+		proto[methodName] = original;
+	} };
+}
+var installed = false;
+var restoreHandles = [];
+function canCreateStencilClipSource(source) {
+	if (source.kind === "bitmap") return source.texture !== void 0;
+	return source.width !== void 0 && source.height !== void 0;
+}
+/** Installs stencil clip helpers on Phaser.GameObjects.Container.prototype. */
+function installStencilClipExtension() {
+	if (installed) return;
+	installed = true;
+	const proto = phaser.GameObjects.Container.prototype;
+	restoreHandles.push(addMethod(proto, "setStencilClip", function(source) {
+		applyStencilClip(this, source);
+		return this;
+	}));
+	restoreHandles.push(addMethod(proto, "updateStencilClip", function(source) {
+		const handle = getStencilClipHandle(this);
+		if (handle) handle.update(source);
+		else if (canCreateStencilClipSource(source)) applyStencilClip(this, source);
+		return this;
+	}));
+	restoreHandles.push(addMethod(proto, "clearStencilClip", function() {
+		clearStencilClip(this);
+		return this;
+	}));
+	restoreHandles.push(addMethod(proto, "getStencilClipHandle", function() {
+		return getStencilClipHandle(this);
+	}));
+	restoreHandles.push(wrapMethod(proto, "destroy", (original, self, ...args) => {
+		clearStencilClip(self);
+		return original.apply(self, args);
+	}));
+}
+/** Restores Phaser prototypes to their previous state. Intended for tests/HMR. */
+function uninstallStencilClipExtension() {
+	for (const handle of [...restoreHandles].reverse()) handle.restore();
+	restoreHandles = [];
+	installed = false;
+}
+//#endregion
+//#region src/clip/index.ts
+installStencilClipExtension();
+//#endregion
+Object.defineProperty(exports, "applyStencilClip", {
+	enumerable: true,
+	get: function() {
+		return applyStencilClip;
+	}
+});
+Object.defineProperty(exports, "clearStencilClip", {
+	enumerable: true,
+	get: function() {
+		return clearStencilClip;
+	}
+});
+Object.defineProperty(exports, "getStencilClipHandle", {
+	enumerable: true,
+	get: function() {
+		return getStencilClipHandle;
+	}
+});
+Object.defineProperty(exports, "installStencilClipExtension", {
+	enumerable: true,
+	get: function() {
+		return installStencilClipExtension;
+	}
+});
+Object.defineProperty(exports, "isBitmapStencilClipSource", {
+	enumerable: true,
+	get: function() {
+		return isBitmapStencilClipSource;
+	}
+});
+Object.defineProperty(exports, "uninstallStencilClipExtension", {
+	enumerable: true,
+	get: function() {
+		return uninstallStencilClipExtension;
+	}
+});
+
+//# sourceMappingURL=clip-CHmjztBQ.cjs.map