@codexo/exojs 0.11.0 → 0.13.0

package/dist/esm/rendering/webgpu/WebGpuPassCoordinator.d.ts

@@ -1,12 +1,12 @@
-import type { Color } from '@/core/Color';
-import { Matrix } from '@/math/Matrix';
-import type { Rectangle } from '@/math/Rectangle';
-import type { Geometry } from '../geometry/Geometry';
-import type { RenderPassCoordinator } from '../pass/RenderPassCoordinator';
-import type { RenderPassDescriptor, RenderPassLoad } from '../pass/RenderPassDescriptor';
-import type { RenderStats } from '../RenderStats';
-import type { RenderTarget } from '../RenderTarget';
-import type { View } from '../View';
+import type { Color } from '#core/Color';
+import { Matrix } from '#math/Matrix';
+import type { Rectangle } from '#math/Rectangle';
+import type { Geometry } from '#rendering/geometry/Geometry';
+import type { RenderPassCoordinator } from '#rendering/pass/RenderPassCoordinator';
+import type { RenderPassDescriptor, RenderPassLoad } from '#rendering/pass/RenderPassDescriptor';
+import type { RenderStats } from '#rendering/RenderStats';
+import type { RenderTarget } from '#rendering/RenderTarget';
+import type { View } from '#rendering/View';
 import { stencilAttachmentFormat } from './WebGpuStencilClipper';
 /** Pixel-space scissor rectangle, as returned by the backend. @internal */
 interface ScissorRect {
@@ -139,3 +139,4 @@ export declare class WebGpuPassCoordinator implements RenderPassCoordinator {
     private _createStencilAttachment;
 }
 export { stencilAttachmentFormat };
+//# sourceMappingURL=WebGpuPassCoordinator.d.ts.map

package/dist/esm/rendering/webgpu/WebGpuPassCoordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGpuPassCoordinator.d.ts","sourceRoot":"","sources":["../../../../src/rendering/webgpu/WebGpuPassCoordinator.ts"],"names":[],"mappings":"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"}

package/dist/esm/rendering/webgpu/WebGpuRepeatingSpriteRenderer.d.ts

@@ -0,0 +1,52 @@
+import type { RepeatingSprite } from '#rendering/sprite/RepeatingSprite';
+import { AbstractWebGpuRenderer } from './AbstractWebGpuRenderer';
+import type { WebGpuBackend } from './WebGpuBackend';
+/** Instanced renderer for {@link RepeatingSprite} using WebGPU. */
+export declare class WebGpuRepeatingSpriteRenderer extends AbstractWebGpuRenderer<RepeatingSprite> {
+    private readonly _projData;
+    private _device;
+    private _uniformBindGroupLayout;
+    private _textureBindGroupLayout;
+    private _shaderModule;
+    private _uniformBuffer;
+    private _indexBuffer;
+    private _transformBindGroup;
+    private _transformStorageBuf;
+    private readonly _pipelines;
+    private readonly _samplers;
+    private _shaderInstBuf;
+    private _shaderInstCapacity;
+    private _shaderInstData;
+    private _shaderInstF32;
+    private _shaderInstU32;
+    private _shaderQuadCount;
+    private _geoInstBuf;
+    private _geoInstCapacity;
+    private _geoInstData;
+    private _geoInstF32;
+    private _geoInstU32;
+    private _geoQuadCount;
+    private _maxNodeIndex;
+    private _currentTexture;
+    private _currentBlendMode;
+    private _currentModeX;
+    private _currentModeY;
+    private _currentPath;
+    private readonly _snapBounds;
+    protected onConnect(backend: WebGpuBackend): void;
+    protected onDisconnect(): void;
+    render(sprite: RepeatingSprite): void;
+    private _writeShaderInstance;
+    private _writeGeoQuads;
+    flush(): void;
+    private _drawShaderBatch;
+    private _drawGeoBatch;
+    destroy(): void;
+    private _getOrCreateSampler;
+    private _getOrCreateTransformBindGroup;
+    private _getPipeline;
+    private _ensureShaderCapacity;
+    private _ensureGeoCapacity;
+    private _growCapacity;
+}
+//# sourceMappingURL=WebGpuRepeatingSpriteRenderer.d.ts.map

package/dist/esm/rendering/webgpu/WebGpuRepeatingSpriteRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGpuRepeatingSpriteRenderer.d.ts","sourceRoot":"","sources":["../../../../src/rendering/webgpu/WebGpuRepeatingSpriteRenderer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAOzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAmIrD,mEAAmE;AACnE,qBAAa,6BAA8B,SAAQ,sBAAsB,CAAC,eAAe,CAAC;IACxF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2E;IAGrG,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,uBAAuB,CAAmC;IAClE,OAAO,CAAC,uBAAuB,CAAmC;IAClE,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,oBAAoB,CAA0B;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwC;IACnE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;IAG3D,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,cAAc,CAA0C;IAChE,OAAO,CAAC,cAAc,CAAyC;IAC/D,OAAO,CAAC,gBAAgB,CAAK;IAG7B,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,YAAY,CAAmC;IACvD,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,aAAa,CAAK;IAG1B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,eAAe,CAAwC;IAC/D,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,YAAY,CAAsC;IAE1D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmB;IAE/C,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAkCjD,SAAS,CAAC,YAAY,IAAI,IAAI;IAuCvB,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IA6C5C,OAAO,CAAC,oBAAoB;IAgD5B,OAAO,CAAC,cAAc;IA+Cf,KAAK,IAAI,IAAI;IAyCpB,OAAO,CAAC,gBAAgB;IAmCxB,OAAO,CAAC,aAAa;IAiCd,OAAO,IAAI,IAAI;IAQtB,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,8BAA8B;IAetC,OAAO,CAAC,YAAY;IA8DpB,OAAO,CAAC,qBAAqB;IAgB7B,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,aAAa;CAKtB"}

package/dist/esm/rendering/webgpu/WebGpuRepeatingSpriteRenderer.js

@@ -0,0 +1,556 @@
+import { Rectangle } from '../../math/Rectangle.js';
+import { computeShaderTiling } from '../sprite/repeatingSpritePlan.js';
+import { Texture } from '../texture/Texture.js';
+import '../types.js';
+import { AbstractWebGpuRenderer } from './AbstractWebGpuRenderer.js';
+import { getWebGpuBlendState } from './WebGpuBlendState.js';
+import { stencilContentDepthStencilState } from './WebGpuStencilState.js';
+
+/// <reference types="@webgpu/types" />
+// ---------------------------------------------------------------------------
+// Shared WGSL declarations — structs, bindings, and output struct used by
+// both the shader path and the geometry path entry points.
+// ---------------------------------------------------------------------------
+const commonWgsl = `
+struct ProjectionUniforms {
+    matrix: mat4x4<f32>,
+};
+struct TransformSlot {
+    m0: vec4<f32>,
+    m1: vec4<f32>,
+    m2: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> projection: ProjectionUniforms;
+@group(0) @binding(1) var<storage, read> transforms: array<TransformSlot>;
+@group(1) @binding(0) var spriteTexture: texture_2d<f32>;
+@group(1) @binding(1) var spriteSampler: sampler;
+
+struct VOut {
+    @builtin(position) pos: vec4<f32>,
+    @location(0) uv:    vec2<f32>,
+    @location(1) color: vec4<f32>,
+};
+`;
+// ---------------------------------------------------------------------------
+// Shader path WGSL — one quad per sprite, UVs computed in vertex shader.
+// ---------------------------------------------------------------------------
+const shaderPathEntries = `
+struct ShaderVIn {
+    @location(0) quadBounds: vec4<f32>,  // x0,y0,x1,y1
+    @location(1) uvParams:   vec4<f32>,  // tilingX, tilingY, offsetU, offsetV
+    @location(2) color:      vec4<f32>,  // RGBA tint
+    @location(3) nodeIndex:  u32,
+};
+
+@vertex
+fn shaderVert(input: ShaderVIn, @builtin(vertex_index) vid: u32) -> VOut {
+    var out: VOut;
+    let cx = ((vid + 1u) >> 1u) & 1u;
+    let cy = vid >> 1u;
+    let lx = select(input.quadBounds.x, input.quadBounds.z, cx == 1u);
+    let ly = select(input.quadBounds.y, input.quadBounds.w, cy == 1u);
+
+    let destW = input.quadBounds.z - input.quadBounds.x;
+    let destH = input.quadBounds.w - input.quadBounds.y;
+
+    let slot = transforms[input.nodeIndex];
+    let wx = slot.m0.x * lx + slot.m0.y * ly + slot.m1.x;
+    let wy = slot.m0.z * lx + slot.m0.w * ly + slot.m1.y;
+    out.pos = projection.matrix * vec4<f32>(wx, wy, 0.0, 1.0);
+
+    let u = select(input.uvParams.z, ((lx - input.quadBounds.x) / destW) * input.uvParams.x + input.uvParams.z, destW > 0.0);
+    let v = select(input.uvParams.w, ((ly - input.quadBounds.y) / destH) * input.uvParams.y + input.uvParams.w, destH > 0.0);
+    out.uv    = vec2<f32>(u, v);
+    out.color = vec4<f32>(input.color.rgb * input.color.a, input.color.a);
+    return out;
+}
+
+@fragment
+fn shaderFrag(input: VOut) -> @location(0) vec4<f32> {
+    return textureSample(spriteTexture, spriteSampler, input.uv) * input.color;
+}
+`;
+// ---------------------------------------------------------------------------
+// Geometry path WGSL — N quads per sprite, UVs pre-computed in CPU.
+// ---------------------------------------------------------------------------
+const geoPathEntries = `
+struct GeoVIn {
+    @location(0) quadBounds: vec4<f32>,  // x0,y0,x1,y1
+    @location(1) uvBounds:   vec4<f32>,  // u0,v0,u1,v1 (normalised, flipY pre-applied)
+    @location(2) color:      vec4<f32>,  // RGBA tint
+    @location(3) nodeIndex:  u32,
+};
+
+@vertex
+fn geoVert(input: GeoVIn, @builtin(vertex_index) vid: u32) -> VOut {
+    var out: VOut;
+    let cx = ((vid + 1u) >> 1u) & 1u;
+    let cy = vid >> 1u;
+    let lx = select(input.quadBounds.x, input.quadBounds.z, cx == 1u);
+    let ly = select(input.quadBounds.y, input.quadBounds.w, cy == 1u);
+
+    let slot = transforms[input.nodeIndex];
+    let wx = slot.m0.x * lx + slot.m0.y * ly + slot.m1.x;
+    let wy = slot.m0.z * lx + slot.m0.w * ly + slot.m1.y;
+    out.pos = projection.matrix * vec4<f32>(wx, wy, 0.0, 1.0);
+
+    let u = select(input.uvBounds.x, input.uvBounds.z, cx == 1u);
+    let v = select(input.uvBounds.y, input.uvBounds.w, cy == 1u);
+    out.uv    = vec2<f32>(u, v);
+    out.color = vec4<f32>(input.color.rgb * input.color.a, input.color.a);
+    return out;
+}
+
+@fragment
+fn geoFrag(input: VOut) -> @location(0) vec4<f32> {
+    return textureSample(spriteTexture, spriteSampler, input.uv) * input.color;
+}
+`;
+// ---------------------------------------------------------------------------
+// Layout constants
+// ---------------------------------------------------------------------------
+const shaderStrideBytes = 40; // float32x4 bounds + float32x4 uvParams + unorm8x4 + uint32
+const geoStrideBytes = 32; // float32x4 bounds + unorm16x4 + unorm8x4 + uint32 (NineSlice layout)
+const projectionByteLength = 64;
+const initialBatchCapacity = 32;
+const indicesPerInstance = 6;
+const quadIndices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+// ---------------------------------------------------------------------------
+// Sampler address mode helper
+// ---------------------------------------------------------------------------
+function repeatModeToAddressMode(mode) {
+    if (mode === 'repeat')
+        return 'repeat';
+    if (mode === 'mirror-repeat')
+        return 'mirror-repeat';
+    return 'clamp-to-edge';
+}
+/** Instanced renderer for {@link RepeatingSprite} using WebGPU. */
+class WebGpuRepeatingSpriteRenderer extends AbstractWebGpuRenderer {
+    _projData = new Float32Array(projectionByteLength / Float32Array.BYTES_PER_ELEMENT);
+    // Shared GPU objects
+    _device = null;
+    _uniformBindGroupLayout = null;
+    _textureBindGroupLayout = null;
+    _shaderModule = null;
+    _uniformBuffer = null;
+    _indexBuffer = null;
+    _transformBindGroup = null;
+    _transformStorageBuf = null;
+    _pipelines = new Map();
+    _samplers = new Map();
+    // Shader-path instance buffer
+    _shaderInstBuf = null;
+    _shaderInstCapacity = 0;
+    _shaderInstData = new ArrayBuffer(0);
+    _shaderInstF32 = new Float32Array(this._shaderInstData);
+    _shaderInstU32 = new Uint32Array(this._shaderInstData);
+    _shaderQuadCount = 0;
+    // Geometry-path instance buffer
+    _geoInstBuf = null;
+    _geoInstCapacity = 0;
+    _geoInstData = new ArrayBuffer(0);
+    _geoInstF32 = new Float32Array(this._geoInstData);
+    _geoInstU32 = new Uint32Array(this._geoInstData);
+    _geoQuadCount = 0;
+    // Shared batch state
+    _maxNodeIndex = 0;
+    _currentTexture = null;
+    _currentBlendMode = null;
+    _currentModeX = null;
+    _currentModeY = null;
+    _currentPath = null;
+    // Reusable scratch for device-snapped bounds ('geometry' mode).
+    _snapBounds = new Rectangle();
+    onConnect(backend) {
+        if (this._device)
+            return;
+        const device = backend.device;
+        this._device = device;
+        this._shaderModule = device.createShaderModule({ code: commonWgsl + shaderPathEntries + geoPathEntries });
+        this._uniformBindGroupLayout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } },
+                { binding: 1, visibility: GPUShaderStage.VERTEX, buffer: { type: 'read-only-storage' } },
+            ],
+        });
+        this._textureBindGroupLayout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+                { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+            ],
+        });
+        this._uniformBuffer = device.createBuffer({
+            size: projectionByteLength,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this._indexBuffer = device.createBuffer({
+            size: quadIndices.byteLength,
+            usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+        });
+        device.queue.writeBuffer(this._indexBuffer, 0, quadIndices.buffer, quadIndices.byteOffset, quadIndices.byteLength);
+    }
+    onDisconnect() {
+        this._shaderInstBuf?.destroy();
+        this._geoInstBuf?.destroy();
+        this._indexBuffer?.destroy();
+        this._uniformBuffer?.destroy();
+        this._pipelines.clear();
+        this._samplers.clear();
+        this._shaderInstBuf = null;
+        this._geoInstBuf = null;
+        this._indexBuffer = null;
+        this._uniformBuffer = null;
+        this._transformBindGroup = null;
+        this._transformStorageBuf = null;
+        this._textureBindGroupLayout = null;
+        this._uniformBindGroupLayout = null;
+        this._shaderModule = null;
+        this._device = null;
+        this._backend = null;
+        this._shaderInstCapacity = 0;
+        this._shaderInstData = new ArrayBuffer(0);
+        this._shaderInstF32 = new Float32Array(this._shaderInstData);
+        this._shaderInstU32 = new Uint32Array(this._shaderInstData);
+        this._geoInstCapacity = 0;
+        this._geoInstData = new ArrayBuffer(0);
+        this._geoInstF32 = new Float32Array(this._geoInstData);
+        this._geoInstU32 = new Uint32Array(this._geoInstData);
+        this._shaderQuadCount = 0;
+        this._geoQuadCount = 0;
+        this._maxNodeIndex = 0;
+        this._currentTexture = null;
+        this._currentBlendMode = null;
+        this._currentModeX = null;
+        this._currentModeY = null;
+        this._currentPath = null;
+    }
+    render(sprite) {
+        const backend = this._backend;
+        if (!backend)
+            return;
+        const texture = sprite.texture;
+        if (texture instanceof Texture && texture.source === null)
+            return;
+        if (texture.width === 0 || texture.height === 0)
+            return;
+        const strategy = sprite.resolvedStrategy;
+        const blendMode = sprite.blendMode;
+        const modeX = sprite.modeX;
+        const modeY = sprite.modeY;
+        const hasData = this._shaderQuadCount > 0 || this._geoQuadCount > 0;
+        if (hasData) {
+            const pathChanged = this._currentPath !== strategy;
+            const texChanged = this._currentTexture !== texture;
+            const blendChanged = this._currentBlendMode !== blendMode;
+            const modeChanged = strategy === 'shader'
+                && (this._currentModeX !== modeX || this._currentModeY !== modeY);
+            if (pathChanged || texChanged || blendChanged || modeChanged) {
+                this.flush();
+            }
+        }
+        this._currentTexture = texture;
+        this._currentBlendMode = blendMode;
+        this._currentPath = strategy;
+        backend.setBlendMode(blendMode);
+        const command = backend.activeDrawCommand;
+        const nodeIndex = command !== null ? command.nodeIndex : backend._pushTransform(sprite);
+        if (nodeIndex > this._maxNodeIndex)
+            this._maxNodeIndex = nodeIndex;
+        if (strategy === 'shader') {
+            this._currentModeX = modeX;
+            this._currentModeY = modeY;
+            this._writeShaderInstance(sprite, nodeIndex);
+        }
+        else {
+            this._writeGeoQuads(sprite, nodeIndex);
+        }
+    }
+    _writeShaderInstance(sprite, nodeIndex) {
+        const texture = sprite.texture;
+        const srcW = sprite.region.width;
+        const srcH = sprite.region.height;
+        let destW = sprite.width;
+        let destH = sprite.height;
+        const flipY = texture instanceof Texture && texture.flipY;
+        // 'geometry' mode: snap the destination quad to the device grid. Repetition
+        // stays shader-based; only the outer rectangle (and the tiling derived from
+        // it) moves. Position/none leave the destination unchanged.
+        if (sprite.pixelSnapMode === 'geometry') {
+            const backend = this.getBackend();
+            const snap = backend._getSnapPixelSize();
+            const rb = sprite.getRenderBounds(backend.view, snap.width, snap.height, this._snapBounds);
+            destW = rb.width;
+            destH = rb.height;
+        }
+        const tilingX = computeShaderTiling(srcW, destW, sprite.modeX, sprite.fitX);
+        const tilingY = computeShaderTiling(srcH, destH, sprite.modeY, sprite.fitY);
+        const offsetU = sprite.offsetX / (srcW > 0 ? srcW : 1);
+        const offsetV = sprite.offsetY / (srcH > 0 ? srcH : 1);
+        const uvParamY = flipY ? -tilingY : tilingY;
+        const uvParamW = flipY ? tilingY + offsetV : offsetV;
+        this._ensureShaderCapacity(this._shaderQuadCount + 1);
+        const words = shaderStrideBytes / 4;
+        const offset = this._shaderQuadCount * words;
+        const f32 = this._shaderInstF32;
+        const u32 = this._shaderInstU32;
+        f32[offset + 0] = 0;
+        f32[offset + 1] = 0;
+        f32[offset + 2] = destW;
+        f32[offset + 3] = destH;
+        f32[offset + 4] = tilingX;
+        f32[offset + 5] = uvParamY;
+        f32[offset + 6] = offsetU;
+        f32[offset + 7] = uvParamW;
+        u32[offset + 8] = sprite.tint.toRgba();
+        u32[offset + 9] = nodeIndex >>> 0;
+        this._shaderQuadCount++;
+    }
+    _writeGeoQuads(sprite, nodeIndex) {
+        let quads = sprite.quads;
+        // 'geometry' mode: snap shared segment boundaries once (gap-free), like NineSlice.
+        if (sprite.pixelSnapMode === 'geometry') {
+            const backend = this.getBackend();
+            const snap = backend._getSnapPixelSize();
+            quads = sprite.getRenderQuads(backend.view, snap.width, snap.height);
+        }
+        if (quads.length === 0)
+            return;
+        const flipY = (sprite.texture instanceof Texture) && sprite.texture.flipY;
+        const tint = sprite.tint.toRgba();
+        const words = geoStrideBytes / 4;
+        this._ensureGeoCapacity(this._geoQuadCount + quads.length);
+        const f32 = this._geoInstF32;
+        const u32 = this._geoInstU32;
+        for (let i = 0; i < quads.length; i++) {
+            const q = quads[i];
+            const offset = (this._geoQuadCount + i) * words;
+            f32[offset + 0] = q.x0;
+            f32[offset + 1] = q.y0;
+            f32[offset + 2] = q.x1;
+            f32[offset + 3] = q.y1;
+            const uMin = (q.u0 * 0xffff) & 0xffff;
+            const uMax = (q.u1 * 0xffff) & 0xffff;
+            const v0Raw = (q.v0 * 0xffff) & 0xffff;
+            const v1Raw = (q.v1 * 0xffff) & 0xffff;
+            const vMin = flipY ? v1Raw : v0Raw;
+            const vMax = flipY ? v0Raw : v1Raw;
+            u32[offset + 4] = uMin | (vMin << 16);
+            u32[offset + 5] = uMax | (vMax << 16);
+            u32[offset + 6] = tint;
+            u32[offset + 7] = nodeIndex >>> 0;
+        }
+        this._geoQuadCount += quads.length;
+    }
+    flush() {
+        const backend = this._backend;
+        const device = this._device;
+        const uniform = this._uniformBuffer;
+        if (!backend || !device || !uniform)
+            return;
+        if (this._shaderQuadCount === 0 && this._geoQuadCount === 0 && !backend.clearRequested) {
+            return;
+        }
+        const vm = backend.view.getTransform();
+        this._projData.set([vm.a, vm.c, 0, 0, vm.b, vm.d, 0, 0, 0, 0, 1, 0, vm.x, vm.y, 0, vm.z]);
+        device.queue.writeBuffer(uniform, 0, this._projData.buffer, this._projData.byteOffset, this._projData.byteLength);
+        const scissor = backend.getScissorRect();
+        const maskClipsAll = scissor !== null && (scissor.width <= 0 || scissor.height <= 0);
+        const pass = backend._passCoordinator.acquirePass().pass;
+        const stencil = backend._passCoordinator.stencilActive;
+        if (this._shaderQuadCount > 0 && !maskClipsAll) {
+            this._drawShaderBatch(device, backend, pass, stencil);
+        }
+        if (this._geoQuadCount > 0 && !maskClipsAll) {
+            this._drawGeoBatch(device, backend, pass, stencil);
+        }
+        backend._passCoordinator.endPass();
+        this._shaderQuadCount = 0;
+        this._geoQuadCount = 0;
+        this._maxNodeIndex = 0;
+        this._currentTexture = null;
+        this._currentBlendMode = null;
+        this._currentModeX = null;
+        this._currentModeY = null;
+        this._currentPath = null;
+    }
+    _drawShaderBatch(device, backend, pass, stencil) {
+        if (!this._shaderInstBuf || !this._indexBuffer || this._currentBlendMode === null || this._currentTexture === null)
+            return;
+        device.queue.writeBuffer(this._shaderInstBuf, 0, this._shaderInstData, 0, this._shaderQuadCount * shaderStrideBytes);
+        const storage = backend.getTransformStorageBuffer(this._maxNodeIndex + 1);
+        const uniformBindGroup = this._getOrCreateTransformBindGroup(device, this._uniformBuffer, storage.buffer);
+        const modeX = this._currentModeX ?? 'repeat';
+        const modeY = this._currentModeY ?? 'repeat';
+        const sampler = this._getOrCreateSampler(device, modeX, modeY);
+        const texView = backend.getTextureBinding(this._currentTexture).view;
+        const textureBindGroup = device.createBindGroup({
+            layout: this._textureBindGroupLayout,
+            entries: [{ binding: 0, resource: texView }, { binding: 1, resource: sampler }],
+        });
+        const pipeline = this._getPipeline('shader', this._currentBlendMode, backend.renderTargetFormat, stencil);
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, uniformBindGroup);
+        pass.setBindGroup(1, textureBindGroup);
+        pass.setVertexBuffer(0, this._shaderInstBuf);
+        pass.setIndexBuffer(this._indexBuffer, 'uint16');
+        pass.drawIndexed(indicesPerInstance, this._shaderQuadCount, 0, 0, 0);
+        backend.stats.batches++;
+        backend.stats.drawCalls++;
+    }
+    _drawGeoBatch(device, backend, pass, stencil) {
+        if (!this._geoInstBuf || !this._indexBuffer || this._currentBlendMode === null || this._currentTexture === null)
+            return;
+        device.queue.writeBuffer(this._geoInstBuf, 0, this._geoInstData, 0, this._geoQuadCount * geoStrideBytes);
+        const storage = backend.getTransformStorageBuffer(this._maxNodeIndex + 1);
+        const uniformBindGroup = this._getOrCreateTransformBindGroup(device, this._uniformBuffer, storage.buffer);
+        // Geometry path: use backend's default (clamp) sampler.
+        const binding = backend.getTextureBinding(this._currentTexture);
+        const textureBindGroup = device.createBindGroup({
+            layout: this._textureBindGroupLayout,
+            entries: [{ binding: 0, resource: binding.view }, { binding: 1, resource: binding.sampler }],
+        });
+        const pipeline = this._getPipeline('geo', this._currentBlendMode, backend.renderTargetFormat, stencil);
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, uniformBindGroup);
+        pass.setBindGroup(1, textureBindGroup);
+        pass.setVertexBuffer(0, this._geoInstBuf);
+        pass.setIndexBuffer(this._indexBuffer, 'uint16');
+        pass.drawIndexed(indicesPerInstance, this._geoQuadCount, 0, 0, 0);
+        backend.stats.batches++;
+        backend.stats.drawCalls++;
+    }
+    destroy() {
+        this.disconnect();
+    }
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+    _getOrCreateSampler(device, modeX, modeY) {
+        const key = `${modeX}:${modeY}`;
+        const existing = this._samplers.get(key);
+        if (existing)
+            return existing;
+        const sampler = device.createSampler({
+            addressModeU: repeatModeToAddressMode(modeX),
+            addressModeV: repeatModeToAddressMode(modeY),
+            magFilter: 'linear',
+            minFilter: 'linear',
+        });
+        this._samplers.set(key, sampler);
+        return sampler;
+    }
+    _getOrCreateTransformBindGroup(device, uniformBuf, storageBuf) {
+        if (this._transformBindGroup !== null && this._transformStorageBuf === storageBuf) {
+            return this._transformBindGroup;
+        }
+        this._transformStorageBuf = storageBuf;
+        this._transformBindGroup = device.createBindGroup({
+            layout: this._uniformBindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer: uniformBuf } },
+                { binding: 1, resource: { buffer: storageBuf } },
+            ],
+        });
+        return this._transformBindGroup;
+    }
+    _getPipeline(kind, blend, format, stencil) {
+        const key = `${kind}:${blend}:${format}:${stencil ? 's' : 'n'}`;
+        const existing = this._pipelines.get(key);
+        if (existing)
+            return existing;
+        if (!this._device || !this._shaderModule || !this._uniformBindGroupLayout || !this._textureBindGroupLayout) {
+            throw new Error('WebGpuRepeatingSpriteRenderer: not connected.');
+        }
+        const layout = this._device.createPipelineLayout({
+            bindGroupLayouts: [this._uniformBindGroupLayout, this._textureBindGroupLayout],
+        });
+        const isShader = kind === 'shader';
+        const strideBytes = isShader ? shaderStrideBytes : geoStrideBytes;
+        const buffers = isShader
+            ? [{
+                    arrayStride: strideBytes,
+                    stepMode: 'instance',
+                    attributes: [
+                        { shaderLocation: 0, offset: 0, format: 'float32x4' },
+                        { shaderLocation: 1, offset: 16, format: 'float32x4' },
+                        { shaderLocation: 2, offset: 32, format: 'unorm8x4' },
+                        { shaderLocation: 3, offset: 36, format: 'uint32' },
+                    ],
+                }]
+            : [{
+                    arrayStride: strideBytes,
+                    stepMode: 'instance',
+                    attributes: [
+                        { shaderLocation: 0, offset: 0, format: 'float32x4' },
+                        { shaderLocation: 1, offset: 16, format: 'unorm16x4' },
+                        { shaderLocation: 2, offset: 24, format: 'unorm8x4' },
+                        { shaderLocation: 3, offset: 28, format: 'uint32' },
+                    ],
+                }];
+        const desc = {
+            layout,
+            vertex: {
+                module: this._shaderModule,
+                entryPoint: isShader ? 'shaderVert' : 'geoVert',
+                buffers,
+            },
+            fragment: {
+                module: this._shaderModule,
+                entryPoint: isShader ? 'shaderFrag' : 'geoFrag',
+                targets: [{ format, blend: getWebGpuBlendState(blend), writeMask: GPUColorWrite.ALL }],
+            },
+            primitive: { topology: 'triangle-list' },
+        };
+        if (stencil) {
+            desc.depthStencil = stencilContentDepthStencilState();
+        }
+        const pipeline = this._device.createRenderPipeline(desc);
+        this._pipelines.set(key, pipeline);
+        return pipeline;
+    }
+    _ensureShaderCapacity(needed) {
+        if (!this._device || needed <= this._shaderInstCapacity)
+            return;
+        this._shaderInstCapacity = this._growCapacity(this._shaderInstCapacity, needed);
+        const oldData = this._shaderInstData;
+        const carry = this._shaderQuadCount * shaderStrideBytes;
+        this._shaderInstData = new ArrayBuffer(this._shaderInstCapacity * shaderStrideBytes);
+        if (carry > 0)
+            new Uint8Array(this._shaderInstData).set(new Uint8Array(oldData, 0, carry));
+        this._shaderInstF32 = new Float32Array(this._shaderInstData);
+        this._shaderInstU32 = new Uint32Array(this._shaderInstData);
+        this._shaderInstBuf?.destroy();
+        this._shaderInstBuf = this._device.createBuffer({
+            size: this._shaderInstData.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+    }
+    _ensureGeoCapacity(needed) {
+        if (!this._device || needed <= this._geoInstCapacity)
+            return;
+        this._geoInstCapacity = this._growCapacity(this._geoInstCapacity, needed);
+        const oldData = this._geoInstData;
+        const carry = this._geoQuadCount * geoStrideBytes;
+        this._geoInstData = new ArrayBuffer(this._geoInstCapacity * geoStrideBytes);
+        if (carry > 0)
+            new Uint8Array(this._geoInstData).set(new Uint8Array(oldData, 0, carry));
+        this._geoInstF32 = new Float32Array(this._geoInstData);
+        this._geoInstU32 = new Uint32Array(this._geoInstData);
+        this._geoInstBuf?.destroy();
+        this._geoInstBuf = this._device.createBuffer({
+            size: this._geoInstData.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+    }
+    _growCapacity(current, needed) {
+        let cap = Math.max(current, initialBatchCapacity);
+        while (cap < needed)
+            cap *= 2;
+        return cap;
+    }
+}
+
+export { WebGpuRepeatingSpriteRenderer };
+//# sourceMappingURL=WebGpuRepeatingSpriteRenderer.js.map