@haiyue/extensions 0.1.0

package/dist/spine/SpineVertexBuilder.d.ts

@@ -0,0 +1,61 @@
+import { Spine2DComponent } from './Spine2DComponent';
+import { SpineFloatBuilder } from './SpineFloatBuilder';
+import type { AtlasRegion } from './SpineAtlasParser';
+import type { BonePose, RegionAttachment, SlotData, SpineData } from './SpineSkeletonRuntime';
+export interface SpineDrawBatch {
+    blend: 'normal' | 'additive';
+    page: string;
+    firstVertex: number;
+    vertexCount: number;
+}
+export interface SpineSlotGeometryCache {
+    key: string;
+    signature: number;
+    debugSignature: number;
+    vertices: Float32Array;
+    vertexLength: number;
+    vertexCapacity: number;
+    debugVertices: Float32Array;
+    debugVertexLength: number;
+    debugVertexCapacity: number;
+    batch: Omit<SpineDrawBatch, 'firstVertex'>;
+    vertexOffset: number;
+    debugVertexOffset: number;
+}
+export interface SpineVertexRuntime {
+    data: SpineData;
+    pages: Map<string, {
+        width: number;
+        height: number;
+    }>;
+    vertexBuilder: SpineFloatBuilder;
+    debugVertexBuilder: SpineFloatBuilder;
+    meshPointBuilder: SpineFloatBuilder;
+    batches: SpineDrawBatch[];
+    batchPool: SpineDrawBatch[];
+    allocationStats?: {
+        batchPoolMisses: number;
+    };
+    vertexColorScratch: [number, number, number, number];
+}
+export declare const HASH_OFFSET = 2166136261;
+export declare function createEmptySlotCache(key: string): SpineSlotGeometryCache;
+export declare function copyBuilderData(builder: SpineFloatBuilder, target: Float32Array): Float32Array;
+export declare function hasInvalidOffsets(entries: SpineSlotGeometryCache[]): boolean;
+export declare function rebuildCachedGeometryLayout(runtime: SpineVertexRuntime, entries: SpineSlotGeometryCache[]): void;
+export declare function rebuildCachedDrawBatches(runtime: SpineVertexRuntime, entries: SpineSlotGeometryCache[]): void;
+export declare function getSlotOrderHash(entries: SpineSlotGeometryCache[]): number;
+export declare function getSlotBuildSignature(slot: SlotData, attachmentName: string, attachment: RegionAttachment, regionName: string, region: AtlasRegion, bone: BonePose, poses: Map<string, BonePose>, slotColor: [number, number, number, number] | undefined, clip: {
+    endSlot?: string;
+    polygon: Array<[number, number]>;
+} | null, component: Spine2DComponent): number;
+export declare function getDebugBonesSignature(scale: number, poses: Map<string, BonePose>): number;
+export declare function hashInt(hash: number, value: number): number;
+export declare function normalizeBlend(blend: string): 'normal' | 'additive';
+export declare function computeClipPolygon(bone: BonePose, attachment: RegionAttachment, scale: number): Array<[number, number]>;
+export declare function replaceClippedRange(floats: SpineFloatBuilder, start: number, polygon: Array<[number, number]>, clipped: SpineFloatBuilder): void;
+export declare function appendRegionVertices(out: SpineFloatBuilder, component: Spine2DComponent, runtime: SpineVertexRuntime, bone: BonePose, slotColor: [number, number, number, number] | undefined, attachment: RegionAttachment, region: AtlasRegion): void;
+export declare function appendMeshVertices(out: SpineFloatBuilder, component: Spine2DComponent, runtime: SpineVertexRuntime, data: SpineData, poses: Map<string, BonePose>, bone: BonePose, slotColor: [number, number, number, number] | undefined, attachment: RegionAttachment, region: AtlasRegion): void;
+export declare function appendMeshWireframe(out: SpineFloatBuilder, component: Spine2DComponent, runtime: SpineVertexRuntime, data: SpineData, poses: Map<string, BonePose>, bone: BonePose, attachment: RegionAttachment): void;
+export declare function appendRegionWireframe(out: SpineFloatBuilder, component: Spine2DComponent, bone: BonePose, attachment: RegionAttachment, region: AtlasRegion): void;
+export declare function appendBoneDebug(out: SpineFloatBuilder, data: SpineData, poses: Map<string, BonePose>, scale: number): void;

package/dist/spine.d.ts

@@ -0,0 +1,7 @@
+export { Spine2DComponent } from './spine/Spine2DComponent';
+export type { Spine2DComponentOptions, Spine2DStatus } from './spine/Spine2DComponent';
+export { Spine2DRenderSystem } from './spine/Spine2DRenderSystem';
+export type { Spine2DRenderSystemOptions } from './spine/Spine2DRenderSystem';
+export type { SpineAssetWorker } from './spine/SpineAssetWorkerContract';
+export { createSpinePlugin } from './spine/SpinePlugin';
+export type { SpinePluginOptions } from './spine/SpinePlugin';

package/dist/spine.js

@@ -0,0 +1,578 @@
+import { S as Spine2DComponent, d as advanceSpineRuntime, g as buildSpineVertices, l as loadSpineRuntime } from './chunks/Spine2DRuntime-D9M9LAQR.js';
+import { requireEngineDevice, getExtensionGPUResourceTracker, alignUp4, beginRenderCommandPass } from '@haiyue/engine/extension-authoring';
+import { EngineError, EngineErrorCode } from '@haiyue/engine';
+import { ErrorRecovery, ErrorDomain } from '@haiyue/engine/core';
+import { r as resolveAtlasPageImageUrl } from './chunks/SpineAssetParser-BSDmPge1.js';
+import { c as createCamera2DGpu, b as createObject2DLayout, e as createTexture2DGpu, d as destroyCamera2DGpu, a as destroyTexture2DGpu, R as RenderSystem2DBase, w as writeObjectMatrixIfChanged } from './chunks/RenderSystem2DBase-DDT61dAu.js';
+import { s as spine2dWgsl } from './chunks/2d-ui-spine2d.generated-CUUi8xjl.js';
+import { E as EXTENSIONS_PLUGIN_VERSION, i as installEditorRenderSystem, r as removeSystem } from './chunks/pluginUtils-CvwroRMd.js';
+import '@haiyue/engine/ecs';
+import '@haiyue/engine/experimental/async';
+import '@haiyue/engine/components';
+import 'wgpu-matrix';
+
+const SPINE_WGSL = spine2dWgsl;
+class Spine2DGpuRenderer {
+    engine = null;
+    cameraGpu = null;
+    textureGpu = null;
+    objectLayoutGpu = null;
+    shaderModule = null;
+    pipelineLayout = null;
+    pipelines = new Map();
+    reverseZ = false;
+    sampleCount = 1;
+    pendingBufferDestroys = new Set();
+    get cameraBuffer() {
+        return this.requirePrepared().cameraGpu.buffer;
+    }
+    get objectLayout() {
+        return this.requirePrepared().objectLayout;
+    }
+    prepare(engine) {
+        if (this.engine === engine && this.cameraGpu && this.textureGpu && this.objectLayoutGpu)
+            return;
+        if (this.engine && this.engine !== engine)
+            this.destroy();
+        this.engine = engine;
+        const device = requireEngineDevice(engine);
+        this.cameraGpu = createCamera2DGpu(device, getExtensionGPUResourceTracker(engine));
+        this.objectLayoutGpu = createObject2DLayout(device);
+        this.textureGpu = createTexture2DGpu(device, 255, getExtensionGPUResourceTracker(engine));
+        this.shaderModule = device.createShaderModule({ code: SPINE_WGSL });
+        this.pipelineLayout = device.createPipelineLayout({
+            bindGroupLayouts: [this.cameraGpu.layout, this.objectLayoutGpu, this.textureGpu.layout],
+        });
+    }
+    destroy() {
+        if (this.cameraGpu)
+            destroyCamera2DGpu(this.cameraGpu);
+        if (this.textureGpu)
+            destroyTexture2DGpu(this.textureGpu);
+        this.flushPendingBufferDestroys();
+        this.cameraGpu = null;
+        this.textureGpu = null;
+        this.objectLayoutGpu = null;
+        this.shaderModule = null;
+        this.pipelineLayout = null;
+        this.pipelines.clear();
+    }
+    setRenderView(reverseZ, sampleCount) {
+        this.reverseZ = reverseZ;
+        this.sampleCount = sampleCount;
+    }
+    createRuntimeBuffers() {
+        const engine = this.requireEngine();
+        const vertexBufferSize = 1024;
+        const debugVertexBufferSize = 1024;
+        const vertexBuffer = engine.device.createBuffer({
+            size: vertexBufferSize,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+        const debugVertexBuffer = engine.device.createBuffer({
+            size: debugVertexBufferSize,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+        getExtensionGPUResourceTracker(engine)?.trackBuffer(vertexBuffer, 'Spine2D.vertexBuffer', vertexBufferSize);
+        getExtensionGPUResourceTracker(engine)?.trackBuffer(debugVertexBuffer, 'Spine2D.debugVertexBuffer', debugVertexBufferSize);
+        return { vertexBuffer, vertexBufferSize, debugVertexBuffer, debugVertexBufferSize };
+    }
+    async loadAtlasPages(component, atlas) {
+        const engine = this.requireEngine();
+        const textureGpu = this.requirePrepared().textureGpu;
+        const pageNames = Array.from(new Set(Array.from(atlas.values()).map(region => region.page).filter(Boolean)));
+        const pages = new Map();
+        const names = pageNames.length ? pageNames : [''];
+        for (const pageName of names) {
+            const imageUrl = resolveAtlasPageImageUrl({
+                atlasUrl: component.atlasUrl,
+                imageUrl: component.imageUrl,
+                imageUrls: component.imageUrls,
+            }, atlas, pageName);
+            const image = await loadImage(imageUrl);
+            const width = Math.max(1, image.naturalWidth || image.width);
+            const height = Math.max(1, image.naturalHeight || image.height);
+            const texture = engine.device.createTexture({
+                size: [width, height],
+                format: 'rgba8unorm',
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+            });
+            getExtensionGPUResourceTracker(engine)?.trackTexture(texture, 'Spine2D.atlasTexture', width * height * 4);
+            engine.device.queue.copyExternalImageToTexture({ source: image }, { texture }, [width, height]);
+            const textureBindGroup = engine.device.createBindGroup({
+                layout: textureGpu.layout,
+                entries: [
+                    { binding: 0, resource: texture.createView() },
+                    { binding: 1, resource: textureGpu.sampler },
+                ],
+            });
+            pages.set(pageName, { image, texture, textureBindGroup, width, height });
+        }
+        return pages;
+    }
+    writeVertices(runtime, vertices, dirtyRanges) {
+        const engine = this.requireEngine();
+        if (vertices.byteLength > runtime.vertexBufferSize) {
+            const nextSize = nextGpuBufferSize(vertices.byteLength, runtime.vertexBufferSize);
+            const nextBuffer = engine.device.createBuffer({
+                size: nextSize,
+                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            });
+            this.deferBufferDestroy(runtime.vertexBuffer);
+            runtime.vertexBuffer = nextBuffer;
+            runtime.vertexBufferSize = nextSize;
+            getExtensionGPUResourceTracker(engine)?.trackBuffer(runtime.vertexBuffer, 'Spine2D.vertexBuffer', nextSize);
+            engine.device.queue.writeBuffer(runtime.vertexBuffer, 0, vertices.data.buffer, 0, vertices.byteLength);
+            return;
+        }
+        this.writeDirtyRanges(runtime, runtime.vertexBuffer, vertices, dirtyRanges, runtime.mergedDirtyRanges);
+    }
+    writeDebugVertices(runtime, vertices, dirtyRanges) {
+        const engine = this.requireEngine();
+        if (vertices.byteLength > runtime.debugVertexBufferSize) {
+            const nextSize = nextGpuBufferSize(vertices.byteLength, runtime.debugVertexBufferSize);
+            const nextBuffer = engine.device.createBuffer({
+                size: nextSize,
+                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            });
+            this.deferBufferDestroy(runtime.debugVertexBuffer);
+            runtime.debugVertexBuffer = nextBuffer;
+            runtime.debugVertexBufferSize = nextSize;
+            getExtensionGPUResourceTracker(engine)?.trackBuffer(runtime.debugVertexBuffer, 'Spine2D.debugVertexBuffer', nextSize);
+            engine.device.queue.writeBuffer(runtime.debugVertexBuffer, 0, vertices.data.buffer, 0, vertices.byteLength);
+            return;
+        }
+        this.writeDirtyRanges(runtime, runtime.debugVertexBuffer, vertices, dirtyRanges, runtime.mergedDirtyRanges);
+    }
+    drawRuntime(pass, runtime, objectBindGroup, debugVertexCount) {
+        const { cameraGpu, textureGpu } = this.requirePrepared();
+        pass.setPipeline(this.getPipeline('normal'));
+        pass.setBindGroup(0, cameraGpu.bindGroup);
+        pass.setBindGroup(1, objectBindGroup);
+        pass.setVertexBuffer(0, runtime.vertexBuffer);
+        let currentBlend = 'normal';
+        let currentPage = '';
+        for (const batch of runtime.batches) {
+            if (batch.blend !== currentBlend) {
+                currentBlend = batch.blend;
+                pass.setPipeline(this.getPipeline(currentBlend));
+                pass.setBindGroup(0, cameraGpu.bindGroup);
+                pass.setBindGroup(1, objectBindGroup);
+                pass.setVertexBuffer(0, runtime.vertexBuffer);
+            }
+            if (batch.page !== currentPage) {
+                currentPage = batch.page;
+                pass.setBindGroup(2, runtime.pages.get(batch.page)?.textureBindGroup ?? textureGpu.fallbackBindGroup);
+            }
+            pass.draw(batch.vertexCount, 1, batch.firstVertex);
+        }
+        if (debugVertexCount > 0) {
+            pass.setPipeline(this.getPipeline('line'));
+            pass.setBindGroup(0, cameraGpu.bindGroup);
+            pass.setBindGroup(1, objectBindGroup);
+            pass.setBindGroup(2, textureGpu.fallbackBindGroup);
+            pass.setVertexBuffer(0, runtime.debugVertexBuffer);
+            pass.draw(debugVertexCount);
+        }
+    }
+    destroyRuntime(runtime) {
+        const engine = this.requireEngine();
+        getExtensionGPUResourceTracker(engine)?.untrackBuffer(runtime.vertexBuffer);
+        getExtensionGPUResourceTracker(engine)?.untrackBuffer(runtime.debugVertexBuffer);
+        runtime.vertexBuffer.destroy();
+        runtime.debugVertexBuffer.destroy();
+        for (const page of runtime.pages.values())
+            this.destroyAtlasPage(page);
+        runtime.pages.clear();
+        runtime.batches.length = 0;
+    }
+    destroyAtlasPage(page) {
+        const engine = this.requireEngine();
+        getExtensionGPUResourceTracker(engine)?.untrackTexture(page.texture);
+        page.texture.destroy();
+    }
+    getPipeline(blend) {
+        const key = `${blend}:${this.reverseZ ? 1 : 0}:${this.sampleCount}`;
+        const cached = this.pipelines.get(key);
+        if (cached)
+            return cached;
+        const engine = this.requireEngine();
+        const prepared = this.requirePrepared();
+        const pipeline = engine.device.createRenderPipeline({
+            layout: prepared.pipelineLayout,
+            vertex: {
+                module: prepared.shaderModule,
+                entryPoint: 'vs_main',
+                buffers: [{
+                        arrayStride: 32,
+                        attributes: [
+                            { shaderLocation: 0, offset: 0, format: 'float32x2' },
+                            { shaderLocation: 1, offset: 8, format: 'float32x2' },
+                            { shaderLocation: 2, offset: 16, format: 'float32x4' },
+                        ],
+                    }],
+            },
+            fragment: {
+                module: prepared.shaderModule,
+                entryPoint: 'fs_main',
+                targets: [{
+                        format: engine.format,
+                        blend: {
+                            color: blend === 'additive'
+                                ? { srcFactor: 'src-alpha', dstFactor: 'one', operation: 'add' }
+                                : { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                        },
+                    }],
+            },
+            primitive: { topology: blend === 'line' ? 'line-list' : 'triangle-list' },
+            depthStencil: {
+                format: engine.getDepthFormat(this.reverseZ),
+                depthWriteEnabled: false,
+                depthCompare: this.reverseZ ? 'greater-equal' : 'less-equal',
+            },
+            multisample: { count: this.sampleCount },
+        });
+        this.pipelines.set(key, pipeline);
+        return pipeline;
+    }
+    writeDirtyRanges(runtime, buffer, vertices, dirtyRanges, mergedRanges) {
+        const engine = this.requireEngine();
+        for (const range of mergeDirtyRanges(dirtyRanges, mergedRanges, runtime.mergedDirtyRangePool, runtime.allocationStats)) {
+            if (range.byteLength <= 0)
+                continue;
+            engine.device.queue.writeBuffer(buffer, range.byteOffset, vertices.data.buffer, range.byteOffset, range.byteLength);
+        }
+    }
+    deferBufferDestroy(buffer) {
+        const engine = this.requireEngine();
+        this.pendingBufferDestroys.add(buffer);
+        void engine.device.queue.onSubmittedWorkDone().finally(() => {
+            if (!this.pendingBufferDestroys.delete(buffer))
+                return;
+            getExtensionGPUResourceTracker(engine)?.untrackBuffer(buffer);
+            buffer.destroy();
+        });
+    }
+    flushPendingBufferDestroys() {
+        const engine = this.engine;
+        for (const buffer of this.pendingBufferDestroys) {
+            if (engine)
+                getExtensionGPUResourceTracker(engine)?.untrackBuffer(buffer);
+            buffer.destroy();
+        }
+        this.pendingBufferDestroys.clear();
+    }
+    requireEngine() {
+        if (!this.engine)
+            throw spineRendererStateError();
+        requireEngineDevice(this.engine);
+        return this.engine;
+    }
+    requirePrepared() {
+        if (!this.cameraGpu
+            || !this.textureGpu
+            || !this.objectLayoutGpu
+            || !this.shaderModule
+            || !this.pipelineLayout) {
+            throw spineRendererStateError();
+        }
+        return {
+            cameraGpu: this.cameraGpu,
+            textureGpu: this.textureGpu,
+            objectLayout: this.objectLayoutGpu,
+            shaderModule: this.shaderModule,
+            pipelineLayout: this.pipelineLayout,
+        };
+    }
+}
+function nextGpuBufferSize(requiredBytes, currentBytes) {
+    const required = Math.max(4, alignUp4(requiredBytes));
+    let next = Math.max(1024, currentBytes);
+    while (next < required)
+        next *= 2;
+    return next;
+}
+function mergeDirtyRanges(ranges, out, pool, allocationStats) {
+    if (ranges.length <= 1)
+        return ranges;
+    ranges.sort((a, b) => a.byteOffset - b.byteOffset);
+    out.length = 0;
+    for (const range of ranges) {
+        const last = out[out.length - 1];
+        if (!last) {
+            pushMergedRange(out, pool, range.byteOffset, range.byteLength, allocationStats);
+            continue;
+        }
+        const lastEnd = last.byteOffset + last.byteLength;
+        if (range.byteOffset <= lastEnd) {
+            last.byteLength = Math.max(lastEnd, range.byteOffset + range.byteLength) - last.byteOffset;
+        }
+        else {
+            pushMergedRange(out, pool, range.byteOffset, range.byteLength, allocationStats);
+        }
+    }
+    return out;
+}
+function pushMergedRange(out, pool, byteOffset, byteLength, allocationStats) {
+    const index = out.length;
+    let range = pool[index];
+    if (!range) {
+        range = { byteOffset, byteLength };
+        pool.push(range);
+        allocationStats.dirtyRangePoolMisses++;
+    }
+    else {
+        range.byteOffset = byteOffset;
+        range.byteLength = byteLength;
+    }
+    out.push(range);
+}
+function loadImage(url) {
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.crossOrigin = 'anonymous';
+        image.onload = () => resolve(image);
+        image.onerror = () => reject(new EngineError(EngineErrorCode.AssetLoadFailed, `Failed to load Spine image: ${url}`, {
+            domain: ErrorDomain.Component,
+            recovery: ErrorRecovery.Retry,
+            context: { url, resourceType: 'skeleton/spine-image' },
+            path: 'spine.atlas.pages',
+        }));
+        image.src = url;
+    });
+}
+function spineRendererStateError() {
+    return new EngineError(EngineErrorCode.RendererResourceNotReady, 'Spine2DGpuRenderer is not prepared.', {
+        domain: ErrorDomain.Component,
+        recovery: ErrorRecovery.TerminateRuntime,
+        path: 'spine.renderer',
+    });
+}
+
+class Spine2DRenderSystem extends RenderSystem2DBase {
+    gpuRenderer = new Spine2DGpuRenderer();
+    runtimes = new Map();
+    entityGpu = new Map();
+    liveComponents = new Set();
+    pendingLoads = new Map();
+    assetWorker;
+    disposed = false;
+    get renderPipelineOptions() {
+        return {
+            pass: 'shared',
+            loadOp: this.loadOp,
+            recordMode: 'delta',
+            sort: this.priority,
+        };
+    }
+    constructor(engine, cameraEntity, options = {}) {
+        super({ all: [Spine2DComponent] }, engine, cameraEntity, options, 'Spine2DRenderSystem');
+        this.assetWorker = options.assetWorker ?? null;
+    }
+    record(world, delta, context) {
+        if (this.disabled || !this.engine.device)
+            return this;
+        this.gpuRenderer.prepare(this.engine);
+        this.gpuRenderer.setRenderView(context.view?.reverseZ ?? this.engine.reverseZ, context.view?.sampleCount ?? this.engine.msaaSamples);
+        const liveEntities = this.beginLiveEntityTracking();
+        this.liveComponents.clear();
+        if (!this.writeCameraBuffer(this.engine.device.queue, this.gpuRenderer.cameraBuffer, context))
+            return this;
+        const { passEncoder: pass, ownsPass } = beginRenderCommandPass(context);
+        const entities = this.entitySet.get(world);
+        if (entities)
+            for (const entity of entities) {
+                if (!this.isEntityRenderable(entity))
+                    continue;
+                const component = entity.getComponent(Spine2DComponent);
+                if (!component || !component.jsonUrl)
+                    continue;
+                this.liveComponents.add(component);
+                this.ensureRuntime(component);
+                const runtime = this.runtimes.get(component);
+                if (!runtime || component.status !== 'loaded')
+                    continue;
+                advanceSpineRuntime(component, delta);
+                const { vertices, debugVertices, vertexDirtyRanges, debugDirtyRanges, verticesChanged, debugVerticesChanged, } = buildSpineVertices(component, runtime);
+                if (vertices.length === 0)
+                    continue;
+                if (verticesChanged)
+                    this.gpuRenderer.writeVertices(runtime, vertices, vertexDirtyRanges);
+                const gpu = this.getEntityGpu(entity);
+                this.markEntityLive(entity);
+                const worldMatrix = this.getWorldMatrix2D(entity, context);
+                writeObjectMatrixIfChanged(this.engine.device.queue, gpu.objectGpu, worldMatrix);
+                if (debugVertices.length > 0) {
+                    if (debugVerticesChanged)
+                        this.gpuRenderer.writeDebugVertices(runtime, debugVertices, debugDirtyRanges);
+                }
+                this.gpuRenderer.drawRuntime(pass, runtime, gpu.objectGpu.bindGroup, debugVertices.length / 8);
+            }
+        if (ownsPass)
+            pass.end();
+        this.releaseEntityGpuEntriesNotIn(this.entityGpu, gpu => this.destroyEntityGpu(gpu), liveEntities);
+        this.releaseRuntimesNotIn(this.liveComponents);
+        return this;
+    }
+    destroy() {
+        this.disposed = true;
+        for (const pending of this.pendingLoads.values())
+            pending.controller.abort('system-destroyed');
+        this.pendingLoads.clear();
+        this.releaseGpuResourcesForRecovery();
+        return super.destroy();
+    }
+    releaseGpuResourcesForRecovery() {
+        for (const pending of this.pendingLoads.values())
+            pending.controller.abort('device-lost');
+        this.pendingLoads.clear();
+        this.destroyEntityGpuEntries(this.entityGpu, gpu => this.destroyEntityGpu(gpu));
+        for (const [component, runtime] of this.runtimes) {
+            this.destroyRuntime(runtime);
+            component.runtimeKey = '';
+            component.loadingKey = '';
+        }
+        this.runtimes.clear();
+        this.gpuRenderer.destroy();
+    }
+    restoreGpuResourcesAfterRecovery() {
+        this.gpuRenderer = new Spine2DGpuRenderer();
+        this.disposed = false;
+    }
+    getEntityGpu(entity) {
+        return this.getOrCreateEntityGpu(this.entityGpu, entity, () => ({
+            objectGpu: this.createObjectGpu(this.gpuRenderer.objectLayout),
+        }));
+    }
+    releaseRuntimesNotIn(liveComponents) {
+        for (const [component, pending] of this.pendingLoads) {
+            if (liveComponents.has(component))
+                continue;
+            pending.controller.abort('component-removed');
+            this.pendingLoads.delete(component);
+            component.loadingKey = '';
+        }
+        for (const [component, runtime] of this.runtimes) {
+            if (!liveComponents.has(component)) {
+                this.destroyRuntime(runtime);
+                this.runtimes.delete(component);
+                component.runtimeKey = '';
+            }
+        }
+    }
+    destroyEntityGpu(gpu) {
+        this.destroyObjectGpu(gpu.objectGpu);
+    }
+    destroyRuntime(runtime) {
+        this.gpuRenderer.destroyRuntime(runtime);
+    }
+    ensureRuntime(component) {
+        const key = component.sourceKey;
+        if (component.runtimeKey === key || component.loadingKey === key)
+            return;
+        const previousPending = this.pendingLoads.get(component);
+        previousPending?.controller.abort('source-changed');
+        this.pendingLoads.delete(component);
+        const previous = this.runtimes.get(component);
+        if (previous) {
+            this.destroyRuntime(previous);
+            this.runtimes.delete(component);
+            component.runtimeKey = '';
+        }
+        component.status = 'loading';
+        component.error = null;
+        component.loadingKey = key;
+        const controller = new AbortController();
+        const pending = { key, controller };
+        this.pendingLoads.set(component, pending);
+        void loadSpineRuntime(this.gpuRenderer, component, { assetWorker: this.assetWorker, signal: controller.signal })
+            .then((runtime) => {
+            if (this.disposed || component.loadingKey !== key) {
+                this.destroyRuntime(runtime);
+                return;
+            }
+            this.runtimes.set(component, runtime);
+            component.runtimeKey = key;
+            component.status = 'loaded';
+            component.elapsed = 0;
+        })
+            .catch((error) => {
+            if (controller.signal.aborted)
+                return;
+            component.status = 'error';
+            component.error = error instanceof Error ? error.message : String(error);
+            console.warn(`[Spine2DRenderSystem] ${component.error}`);
+        })
+            .finally(() => {
+            if (this.pendingLoads.get(component) === pending)
+                this.pendingLoads.delete(component);
+            if (component.loadingKey === key)
+                component.loadingKey = '';
+        });
+    }
+}
+
+function createSpinePlugin(options = {}) {
+    let system = null;
+    return {
+        name: '@haiyue/extensions/spine',
+        version: EXTENSIONS_PLUGIN_VERSION,
+        installEngine(context) {
+            context.registerComponent({ type: 'Spine2DComponent', component: Spine2DComponent });
+        },
+        installScene(context) {
+            context.registerComponent({ type: 'Spine2DComponent', component: Spine2DComponent });
+            system = new Spine2DRenderSystem(context.engine, context.cameraEntity, options.system);
+            context.addSystem(system, options.render ?? { pass: 'shared', loadOp: system.loadOp });
+        },
+        uninstallScene(context) {
+            removeSystem(context, system);
+            system = null;
+        },
+        installEditor(context) {
+            context.registerContribution({ components: [{
+                        type: 'Spine2DComponent',
+                        create: () => new Spine2DComponent({ jsonUrl: '', atlasUrl: '', imageUrl: '', scale: 1 }),
+                        inspector: Spine2DComponent.editor,
+                        serialize(component) {
+                            return {
+                                type: 'Spine2DComponent',
+                                jsonUrl: component.jsonUrl,
+                                atlasUrl: component.atlasUrl,
+                                imageUrl: component.imageUrl,
+                                imageUrls: { ...component.imageUrls },
+                                skin: component.skin,
+                                animation: component.animation,
+                                loop: component.loop,
+                                timeScale: component.timeScale,
+                                scale: component.scale,
+                                premultipliedAlpha: component.premultipliedAlpha,
+                            };
+                        },
+                        deserialize(data) {
+                            const value = data;
+                            return value.type === 'Spine2DComponent' ? new Spine2DComponent(value) : null;
+                        },
+                        clone: (component) => component.clone(),
+                        installViewport(viewport) {
+                            return installEditorRenderSystem(viewport, Spine2DRenderSystem, () => new Spine2DRenderSystem(viewport.engine, viewport.camera2DEntity, options.system));
+                        },
+                        runtimeExport: {
+                            imports: [{ from: '@haiyue/extensions/spine', names: ['Spine2DComponent', 'Spine2DRenderSystem'] }],
+                            systems: ['Spine2DRenderSystem'],
+                            deserializeExpression: 'new Spine2DComponent(data)',
+                            installSystems: `  const spineCamera = findCamera2DEntity(world);
+  if (spineCamera && hasComponentType(world, Spine2DComponent)) {
+    applyViewportSettingsToCamera2D(spineCamera, scene.globals);
+    addRenderSystem(new Spine2DRenderSystem(engine, spineCamera, { loadOp: 'load', priority: 3 }), { pass: 'shared', loadOp: 'load' });
+  }`,
+                            has2D: true,
+                        },
+                    }] });
+        },
+    };
+}
+
+export { Spine2DComponent, Spine2DRenderSystem, createSpinePlugin };
+//# sourceMappingURL=spine.js.map