@haiyue/extensions 0.1.0

package/dist/benchmark.d.ts

@@ -0,0 +1,30 @@
+import { Spine2DComponent } from './spine/Spine2DComponent';
+import { type SpineRuntime } from './spine/Spine2DRuntime';
+import { type SpineTimelineSamplerState } from './spine/SpineTimelineRuntime';
+/** Internal benchmark adapter. This file is built for the monorepo harness, not exported by the package. */
+export declare function benchmarkSpineParse(data: {
+    bones: Array<{
+        name: string;
+        parent?: string;
+    }>;
+    slots: Array<{
+        name: string;
+        bone?: string;
+    }>;
+    skins?: object;
+}, atlas: string): number;
+export interface SpineAnimationBenchmarkState {
+    readonly component: Spine2DComponent;
+    readonly runtime: SpineRuntime;
+    readonly boneCount: number;
+    readonly slotCount: number;
+    readonly keyframeCount: number;
+}
+export declare function createSpineAnimationBenchmarkState(boneCount: number, slotCount: number, keyframeCount: number): SpineAnimationBenchmarkState;
+export declare function benchmarkSpineAnimationSample(state: SpineAnimationBenchmarkState): number;
+export declare function benchmarkSpineVertexBuild(state: SpineAnimationBenchmarkState): number;
+export declare function benchmarkCompileSpineTimeline(frames: unknown[]): number;
+export declare function benchmarkCreateSpineTimelineSamplerState(): SpineTimelineSamplerState;
+export declare function benchmarkSampleSpineTimeline(frames: unknown[], time: number, key: string, fallback: number, samplerState?: SpineTimelineSamplerState): number;
+export declare function benchmarkFindSpineFrame(frames: unknown[], time: number, samplerState?: SpineTimelineSamplerState): number;
+export declare function benchmarkSampleSpineColor(frames: unknown[], time: number, fallback: [number, number, number, number], out: [number, number, number, number]): [number, number, number, number];

package/dist/benchmark.js

@@ -0,0 +1,119 @@
+import { n as normalizeSpineData, p as parseAtlas } from './chunks/SpineAssetParser-BSDmPge1.js';
+import { c as compileSpineTimelines, a as createSpineTimelineSamplerState, f as findCompiledFrameIndex, s as sampleCompiledColor, b as sampleCompiledTimeline, d as advanceSpineRuntime, e as sampleSpinePosesForBenchmark, g as buildSpineVertices, S as Spine2DComponent, h as createSpineRuntimeForBenchmark } from './chunks/Spine2DRuntime-D9M9LAQR.js';
+import '@haiyue/engine';
+import '@haiyue/engine/core';
+import '@haiyue/engine/ecs';
+import '@haiyue/engine/experimental/async';
+
+/** Internal benchmark adapter. This file is built for the monorepo harness, not exported by the package. */
+function benchmarkSpineParse(data, atlas) {
+    return normalizeSpineData(data).bones.length + parseAtlas(atlas).size;
+}
+function createSpineAnimationBenchmarkState(boneCount, slotCount, keyframeCount) {
+    const animationDuration = 2;
+    const frameStep = animationDuration / Math.max(1, keyframeCount - 1);
+    const bones = Array.from({ length: boneCount }, (_, boneIndex) => ({
+        name: `bone${boneIndex}`,
+        ...(boneIndex > 0 ? { parent: `bone${boneIndex - 1}` } : {}),
+        x: boneIndex > 0 ? 1 : 0,
+        length: 1,
+    }));
+    const slots = Array.from({ length: slotCount }, (_, slotIndex) => ({
+        name: `slot${slotIndex}`,
+        bone: `bone${slotIndex % boneCount}`,
+        attachment: `region${slotIndex}`,
+    }));
+    const skin = {};
+    const slotAnimations = {};
+    const atlas = new Map();
+    for (let slotIndex = 0; slotIndex < slotCount; slotIndex++) {
+        const regionName = `region${slotIndex}`;
+        skin[`slot${slotIndex}`] = {
+            [regionName]: { type: 'region', name: regionName, path: regionName, width: 8, height: 8 },
+        };
+        slotAnimations[`slot${slotIndex}`] = {
+            rgba: [
+                { time: 0, color: 'ffffffff', curve: [0.25, 1, 0.75, 0.8, 0.25, 1, 0.75, 0.7, 0.25, 1, 0.75, 0.6, 0.25, 1, 0.75, 1] },
+                { time: animationDuration, color: '80a0c0ff' },
+            ],
+        };
+        atlas.set(regionName, {
+            name: regionName,
+            page: 'page.png',
+            x: (slotIndex % 16) * 8,
+            y: Math.floor(slotIndex / 16) * 8,
+            width: 8,
+            height: 8,
+            originalWidth: 8,
+            originalHeight: 8,
+            offsetX: 0,
+            offsetY: 0,
+            rotate: 0,
+        });
+    }
+    const boneAnimations = {};
+    for (let boneIndex = 0; boneIndex < boneCount; boneIndex++) {
+        const rotate = [];
+        const translate = [];
+        for (let frameIndex = 0; frameIndex < keyframeCount; frameIndex++) {
+            const time = frameIndex * frameStep;
+            const angle = Math.sin(frameIndex * 0.17 + boneIndex * 0.03) * 20;
+            const nextAngle = Math.sin((frameIndex + 1) * 0.17 + boneIndex * 0.03) * 20;
+            rotate.push(frameIndex + 1 < keyframeCount
+                ? { time, angle, curve: [time + frameStep * 0.25, angle, time + frameStep * 0.75, nextAngle] }
+                : { time, angle });
+            translate.push({ time, x: Math.sin(frameIndex * 0.11) * 0.1, y: Math.cos(frameIndex * 0.13) * 0.1 });
+        }
+        boneAnimations[`bone${boneIndex}`] = { rotate, translate };
+    }
+    const data = normalizeSpineData({
+        bones,
+        slots,
+        skins: { default: skin },
+        animations: { benchmark: { bones: boneAnimations, slots: slotAnimations } },
+    });
+    const pages = new Map([[
+            'page.png',
+            {
+                image: null,
+                texture: null,
+                textureBindGroup: null,
+                width: 256,
+                height: 256,
+            },
+        ]]);
+    return {
+        component: new Spine2DComponent({ animation: 'benchmark', loop: true }),
+        runtime: createSpineRuntimeForBenchmark(data, atlas, pages),
+        boneCount,
+        slotCount,
+        keyframeCount,
+    };
+}
+function benchmarkSpineAnimationSample(state) {
+    advanceSpineRuntime(state.component, 16);
+    return sampleSpinePosesForBenchmark(state.component, state.runtime);
+}
+function benchmarkSpineVertexBuild(state) {
+    advanceSpineRuntime(state.component, 16);
+    const result = buildSpineVertices(state.component, state.runtime);
+    return result.vertices.length + result.batches.length + result.vertexDirtyRanges.length;
+}
+function benchmarkCompileSpineTimeline(frames) {
+    return compileSpineTimelines({ benchmark: { timeline: frames } }).frameCount;
+}
+function benchmarkCreateSpineTimelineSamplerState() {
+    return createSpineTimelineSamplerState();
+}
+function benchmarkSampleSpineTimeline(frames, time, key, fallback, samplerState) {
+    return sampleCompiledTimeline(frames, time, key, fallback, 0, false, samplerState);
+}
+function benchmarkFindSpineFrame(frames, time, samplerState) {
+    return findCompiledFrameIndex(frames, time, samplerState);
+}
+function benchmarkSampleSpineColor(frames, time, fallback, out) {
+    return sampleCompiledColor(frames, time, fallback, out);
+}
+
+export { benchmarkCompileSpineTimeline, benchmarkCreateSpineTimelineSamplerState, benchmarkFindSpineFrame, benchmarkSampleSpineColor, benchmarkSampleSpineTimeline, benchmarkSpineAnimationSample, benchmarkSpineParse, benchmarkSpineVertexBuild, createSpineAnimationBenchmarkState };
+//# sourceMappingURL=benchmark.js.map

package/dist/canvas-text/CanvasText2DRenderSystem.d.ts

@@ -0,0 +1,24 @@
+import { type IEngine, type RenderCommandContext } from '@haiyue/engine/extension-authoring';
+import { Entity, type World } from '@haiyue/engine/ecs';
+import { RenderSystem2DBase, type RenderSystem2DBaseOptions } from '../utils/RenderSystem2DBase';
+export type CanvasText2DRenderSystemOptions = RenderSystem2DBaseOptions;
+export declare class CanvasText2DRenderSystem extends RenderSystem2DBase {
+    private rendererReady;
+    private cameraGpu;
+    private objectLayout;
+    private textureGpu;
+    private shaderModule;
+    private pipelineLayout;
+    private pipelineCache;
+    private entityGpu;
+    constructor(engine: IEngine, cameraEntity: Entity, options?: CanvasText2DRenderSystemOptions);
+    record(world: World, context: RenderCommandContext): this;
+    destroy(): this;
+    protected releaseGpuResourcesForRecovery(): void;
+    private prepare;
+    private getPipeline;
+    private getEntityGpu;
+    private getTextureBindGroup;
+    private buildVertices;
+    private destroyEntityGpu;
+}

package/dist/canvas-text/CanvasTextComponent.d.ts

@@ -0,0 +1,18 @@
+import { Component } from '@haiyue/engine';
+import { CssMaterial, type CssMaterialStyle } from '@haiyue/engine/material';
+export interface CanvasTextComponentOptions {
+    text?: string;
+    style?: CssMaterialStyle;
+    material?: CssMaterial;
+}
+export declare class CanvasTextComponent extends Component {
+    static UniqueCheckType: number;
+    static UniqueSymbol: symbol;
+    material: CssMaterial;
+    constructor(options?: CanvasTextComponentOptions);
+    get text(): string;
+    set text(value: string);
+    get style(): CssMaterialStyle;
+    set style(value: CssMaterialStyle);
+    clone(): CanvasTextComponent;
+}

package/dist/canvas-text.d.ts

@@ -0,0 +1,4 @@
+export { CanvasTextComponent } from './canvas-text/CanvasTextComponent';
+export type { CanvasTextComponentOptions } from './canvas-text/CanvasTextComponent';
+export { CanvasText2DRenderSystem } from './canvas-text/CanvasText2DRenderSystem';
+export type { CanvasText2DRenderSystemOptions } from './canvas-text/CanvasText2DRenderSystem';

package/dist/canvas-text.js

@@ -0,0 +1,276 @@
+import { Component } from '@haiyue/engine';
+import { UniqueCheckType } from '@haiyue/engine/ecs';
+import { CssMaterial } from '@haiyue/engine/material';
+import { beginRenderCommandPass, getExtensionGPUResourceTracker, requireEngineDevice } from '@haiyue/engine/extension-authoring';
+import { Transform2D } from '@haiyue/engine/components';
+import { R as RenderSystem2DBase, w as writeObjectMatrixIfChanged, d as destroyCamera2DGpu, a as destroyTexture2DGpu, c as createCamera2DGpu, b as createObject2DLayout, e as createTexture2DGpu } from './chunks/RenderSystem2DBase-DDT61dAu.js';
+import { C as CanvasText2dWgsl } from './chunks/2d-ui-canvas-text-2d.generated-C0Eaej2m.js';
+import 'wgpu-matrix';
+
+class CanvasTextComponent extends Component {
+    static UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+    static UniqueSymbol = Symbol.for('CanvasTextComponent');
+    material;
+    constructor(options = {}) {
+        super('CanvasTextComponent');
+        this.material = options.material ?? new CssMaterial({
+            ...(options.text === undefined ? {} : { text: options.text }),
+            ...(options.style === undefined ? {} : { style: options.style }),
+        });
+    }
+    get text() {
+        return this.material.text;
+    }
+    set text(value) {
+        this.material.setText(value);
+    }
+    get style() {
+        return this.material.style;
+    }
+    set style(value) {
+        this.material.setStyle(value);
+    }
+    clone() {
+        return new CanvasTextComponent({
+            text: this.text,
+            style: { ...this.style },
+        });
+    }
+}
+
+const CANVAS_TEXT_2D_WGSL = CanvasText2dWgsl;
+function textureSize(source) {
+    return {
+        width: Math.max(1, source instanceof HTMLImageElement ? source.naturalWidth || source.width : source.width),
+        height: Math.max(1, source instanceof HTMLImageElement ? source.naturalHeight || source.height : source.height),
+    };
+}
+class CanvasText2DRenderSystem extends RenderSystem2DBase {
+    rendererReady = false;
+    cameraGpu;
+    objectLayout;
+    textureGpu;
+    shaderModule;
+    pipelineLayout;
+    pipelineCache = new Map();
+    entityGpu = new Map();
+    constructor(engine, cameraEntity, options = {}) {
+        super({ all: [CanvasTextComponent, Transform2D] }, engine, cameraEntity, options, 'CanvasText2DRenderSystem');
+    }
+    record(world, context) {
+        if (this.disabled)
+            return this;
+        const { device } = context;
+        if (!this.rendererReady)
+            this.prepare();
+        const liveEntities = this.beginLiveEntityTracking();
+        if (!this.writeCameraBuffer(device.queue, this.cameraGpu.buffer, context))
+            return this;
+        const { passEncoder, ownsPass } = beginRenderCommandPass(context);
+        passEncoder.setPipeline(this.getPipeline(context.view?.reverseZ ?? this.engine.reverseZ, context.view?.sampleCount ?? this.engine.msaaSamples));
+        passEncoder.setBindGroup(0, this.cameraGpu.bindGroup);
+        const entities = this.entitySet.get(world);
+        if (entities)
+            for (const entity of entities) {
+                if (!this.isEntityRenderable(entity))
+                    continue;
+                const component = entity.getComponent(CanvasTextComponent);
+                if (!component)
+                    continue;
+                const textureBindGroup = this.getTextureBindGroup(entity, component);
+                const gpu = this.getEntityGpu(entity);
+                const vertices = this.buildVertices(component, gpu);
+                let shouldUploadVertices = gpu.vertexDirty;
+                if (vertices.byteLength > gpu.vertexBufferSize) {
+                    getExtensionGPUResourceTracker(this.engine)?.untrackBuffer(gpu.vertexBuffer);
+                    gpu.vertexBuffer.destroy();
+                    gpu.vertexBufferSize = Math.max(vertices.byteLength, gpu.vertexBufferSize * 2);
+                    gpu.vertexBuffer = device.createBuffer({
+                        size: gpu.vertexBufferSize,
+                        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+                    });
+                    getExtensionGPUResourceTracker(this.engine)?.trackBuffer(gpu.vertexBuffer, 'CanvasText2D.vertexBuffer', gpu.vertexBufferSize);
+                    shouldUploadVertices = true;
+                }
+                if (shouldUploadVertices) {
+                    device.queue.writeBuffer(gpu.vertexBuffer, 0, vertices.buffer, vertices.byteOffset, vertices.byteLength);
+                    gpu.vertexDirty = false;
+                }
+                const worldMatrix = this.getWorldMatrix2D(entity, context);
+                writeObjectMatrixIfChanged(device.queue, gpu.objectGpu, worldMatrix);
+                passEncoder.setBindGroup(1, gpu.objectGpu.bindGroup);
+                passEncoder.setBindGroup(2, textureBindGroup);
+                passEncoder.setVertexBuffer(0, gpu.vertexBuffer);
+                passEncoder.draw(6);
+                this.markEntityLive(entity);
+            }
+        if (ownsPass)
+            passEncoder.end();
+        this.releaseEntityGpuEntriesNotIn(this.entityGpu, gpu => this.destroyEntityGpu(gpu), liveEntities);
+        return this;
+    }
+    destroy() {
+        this.releaseGpuResourcesForRecovery();
+        return super.destroy();
+    }
+    releaseGpuResourcesForRecovery() {
+        if (this.cameraGpu)
+            destroyCamera2DGpu(this.cameraGpu);
+        if (this.textureGpu)
+            destroyTexture2DGpu(this.textureGpu);
+        this.destroyEntityGpuEntries(this.entityGpu, gpu => this.destroyEntityGpu(gpu));
+        this.pipelineCache.clear();
+        this.rendererReady = false;
+    }
+    prepare() {
+        this.rendererReady = true;
+        const device = requireEngineDevice(this.engine);
+        this.cameraGpu = createCamera2DGpu(device, getExtensionGPUResourceTracker(this.engine));
+        this.objectLayout = createObject2DLayout(device);
+        this.textureGpu = createTexture2DGpu(device, 0, getExtensionGPUResourceTracker(this.engine));
+        this.shaderModule = device.createShaderModule({ code: CANVAS_TEXT_2D_WGSL });
+        this.pipelineLayout = device.createPipelineLayout({
+            bindGroupLayouts: [this.cameraGpu.layout, this.objectLayout, this.textureGpu.layout],
+        });
+    }
+    getPipeline(reverseZ, sampleCount) {
+        const key = (reverseZ ? 1 : 0) | ((sampleCount > 1 ? 1 : 0) << 1);
+        const cached = this.pipelineCache.get(key);
+        if (cached)
+            return cached;
+        const device = requireEngineDevice(this.engine);
+        const { format } = this.engine;
+        const pipeline = device.createRenderPipeline({
+            layout: this.pipelineLayout,
+            vertex: {
+                module: this.shaderModule,
+                entryPoint: 'vs_main',
+                buffers: [{
+                        arrayStride: 16,
+                        attributes: [
+                            { shaderLocation: 0, offset: 0, format: 'float32x2' },
+                            { shaderLocation: 1, offset: 8, format: 'float32x2' },
+                        ],
+                    }],
+            },
+            fragment: {
+                module: this.shaderModule,
+                entryPoint: 'fs_main',
+                targets: [{
+                        format,
+                        blend: {
+                            color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                        },
+                    }],
+            },
+            primitive: { topology: 'triangle-list', cullMode: 'none' },
+            depthStencil: {
+                format: this.engine.getDepthFormat(reverseZ),
+                depthWriteEnabled: false,
+                depthCompare: 'always',
+            },
+            multisample: { count: sampleCount },
+        });
+        this.pipelineCache.set(key, pipeline);
+        return pipeline;
+    }
+    getEntityGpu(entity) {
+        return this.getOrCreateEntityGpu(this.entityGpu, entity, () => {
+            const device = requireEngineDevice(this.engine);
+            const gpu = {
+                vertexBuffer: device.createBuffer({ size: 96, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST }),
+                vertexBufferSize: 96,
+                vertexData: new Float32Array(24),
+                vertexDirty: true,
+                vertexWidth: 0,
+                vertexHeight: 0,
+                objectGpu: this.createObjectGpu(this.objectLayout),
+                texture: null,
+                textureSource: null,
+                textureVersion: -1,
+                textureWidth: 0,
+                textureHeight: 0,
+                textureBindGroup: null,
+            };
+            getExtensionGPUResourceTracker(this.engine)?.trackBuffer(gpu.vertexBuffer, 'CanvasText2D.vertexBuffer', gpu.vertexBufferSize);
+            return gpu;
+        });
+    }
+    getTextureBindGroup(entity, component) {
+        const device = requireEngineDevice(this.engine);
+        const source = component.material.texture;
+        if (!source || !(source instanceof ImageBitmap || source instanceof HTMLCanvasElement || source instanceof HTMLImageElement)) {
+            return this.textureGpu.fallbackBindGroup;
+        }
+        const gpu = this.getEntityGpu(entity);
+        const size = textureSize(source);
+        const textureVersion = component.material.textureVersion;
+        if (gpu.textureBindGroup &&
+            gpu.textureSource === source &&
+            gpu.textureVersion === textureVersion &&
+            gpu.textureWidth === size.width &&
+            gpu.textureHeight === size.height) {
+            return gpu.textureBindGroup;
+        }
+        const canReuseTexture = gpu.texture && gpu.textureWidth === size.width && gpu.textureHeight === size.height;
+        if (!canReuseTexture) {
+            if (gpu.texture)
+                getExtensionGPUResourceTracker(this.engine)?.untrackTexture(gpu.texture);
+            gpu.texture?.destroy();
+            const texture = device.createTexture({
+                size: [size.width, size.height],
+                format: 'rgba8unorm',
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+            });
+            gpu.texture = texture;
+            getExtensionGPUResourceTracker(this.engine)?.trackTexture(texture, 'CanvasText2D.texture', size.width * size.height * 4);
+            gpu.textureBindGroup = device.createBindGroup({
+                layout: this.textureGpu.layout,
+                entries: [
+                    { binding: 0, resource: texture.createView() },
+                    { binding: 1, resource: this.textureGpu.sampler },
+                ],
+            });
+        }
+        const texture = gpu.texture;
+        const textureBindGroup = gpu.textureBindGroup;
+        if (!texture || !textureBindGroup)
+            throw new Error('CanvasText2D texture GPU state is incomplete.');
+        device.queue.copyExternalImageToTexture({ source }, { texture }, [size.width, size.height]);
+        gpu.textureSource = source;
+        gpu.textureVersion = textureVersion;
+        gpu.textureWidth = size.width;
+        gpu.textureHeight = size.height;
+        return textureBindGroup;
+    }
+    buildVertices(component, gpu) {
+        const width = Math.max(1, Number(component.style.width ?? 256));
+        const height = Math.max(1, Number(component.style.height ?? 96));
+        if (gpu.vertexWidth !== width || gpu.vertexHeight !== height) {
+            gpu.vertexWidth = width;
+            gpu.vertexHeight = height;
+            gpu.vertexData.set([
+                0, 0, 0, 1,
+                width, 0, 1, 1,
+                width, height, 1, 0,
+                0, 0, 0, 1,
+                width, height, 1, 0,
+                0, height, 0, 0,
+            ]);
+            gpu.vertexDirty = true;
+        }
+        return gpu.vertexData;
+    }
+    destroyEntityGpu(gpu) {
+        getExtensionGPUResourceTracker(this.engine)?.untrackBuffer(gpu.vertexBuffer);
+        gpu.vertexBuffer.destroy();
+        this.destroyObjectGpu(gpu.objectGpu);
+        if (gpu.texture)
+            getExtensionGPUResourceTracker(this.engine)?.untrackTexture(gpu.texture);
+        gpu.texture?.destroy();
+    }
+}
+
+export { CanvasText2DRenderSystem, CanvasTextComponent };
+//# sourceMappingURL=canvas-text.js.map

package/dist/chunks/2d-ui-animation-2d.generated-D4aHzFU2.js

@@ -0,0 +1,4 @@
+var Animation2dWgsl = "// haiyue:builtin-render animation-2d\n// source: shader-language/builtin-components-2d-ui-family.json\n\nstruct CameraUniforms {\n  viewProj : mat4x4<f32>,\n}\n\nstruct ObjectUniforms {\n  model : mat4x4<f32>,\n  color : vec4<f32>,\n  params : vec4<f32>, // x: composite layer count, y: output offscreen source\n  uvRect : vec4<f32>,\n  compositeParams : array<vec4<f32>, 8>, // mode, operation, feather x/y\n  compositeExpansion0 : vec4<f32>,\n  compositeExpansion1 : vec4<f32>,\n  gradientParams : vec4<f32>, // kind, stop count, opacity\n  gradientGeometry : vec4<f32>, // start.xy, end.xy\n  gradientColors : array<vec4<f32>, 8>,\n  gradientOffsets0 : vec4<f32>,\n  gradientOffsets1 : vec4<f32>,\n  effectKinds0 : vec4<f32>,\n  effectKinds1 : vec4<f32>,\n  effectData : array<EffectData, 8>,\n}\n\nstruct EffectData {\n  data0 : vec4<f32>,\n  data1 : vec4<f32>,\n  data2 : vec4<f32>,\n  data3 : vec4<f32>,\n  data4 : vec4<f32>,\n  data5 : vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> camera : CameraUniforms;\n@group(1) @binding(0) var<uniform> object : ObjectUniforms;\n@group(2) @binding(0) var baseTexture : texture_2d<f32>;\n@group(2) @binding(1) var baseSampler : sampler;\n@group(3) @binding(0) var compositeTexture0 : texture_2d<f32>;\n@group(3) @binding(1) var compositeTexture1 : texture_2d<f32>;\n@group(3) @binding(2) var compositeTexture2 : texture_2d<f32>;\n@group(3) @binding(3) var compositeTexture3 : texture_2d<f32>;\n@group(3) @binding(4) var compositeTexture4 : texture_2d<f32>;\n@group(3) @binding(5) var compositeTexture5 : texture_2d<f32>;\n@group(3) @binding(6) var compositeTexture6 : texture_2d<f32>;\n@group(3) @binding(7) var compositeTexture7 : texture_2d<f32>;\n@group(3) @binding(8) var compositeSampler : sampler;\n\nstruct VertexInput {\n  @location(0) position : vec2<f32>,\n  @location(1) uv : vec2<f32>,\n}\n\nstruct VertexOutput {\n  @builtin(position) clipPos : vec4<f32>,\n  @location(0) uv : vec2<f32>,\n  @location(1) localPosition : vec2<f32>,\n}\n\n@vertex\nfn vs_main(input : VertexInput) -> VertexOutput {\n  var out : VertexOutput;\n  out.clipPos = camera.viewProj * object.model * vec4<f32>(input.position, 0.0, 1.0);\n  out.uv = object.uvRect.xy + input.uv * object.uvRect.zw;\n  out.localPosition = input.position;\n  return out;\n}\n\nstruct EffectVertexOutput {\n  @builtin(position) clipPos : vec4<f32>,\n  @location(0) uv : vec2<f32>,\n  @location(1) @interpolate(flat) effectIndex : u32,\n}\n\n@vertex\nfn vs_effect(@builtin(vertex_index) vertexIndex : u32, @builtin(instance_index) effectIndex : u32) -> EffectVertexOutput {\n  let uv = vec2<f32>(f32((vertexIndex << 1u) & 2u), f32(vertexIndex & 2u));\n  var out : EffectVertexOutput;\n  out.clipPos = vec4<f32>(uv * vec2<f32>(2.0, -2.0) + vec2<f32>(-1.0, 1.0), 0.0, 1.0);\n  out.uv = uv;\n  out.effectIndex = effectIndex;\n  return out;\n}\n\nfn decode_coverage(value : vec4<f32>, mode : f32) -> f32 {\n  var coverage = select(value.a, dot(value.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)), mode > 1.5);\n  if ((mode > 0.5 && mode < 1.5) || mode > 2.5) { coverage = 1.0 - coverage; }\n  return clamp(coverage, 0.0, 1.0);\n}\n\nfn filtered_coverage(\n  source : texture_2d<f32>,\n  uv : vec2<f32>,\n  parameters : vec4<f32>,\n  expansion : f32,\n) -> f32 {\n  let dimensions = vec2<f32>(textureDimensions(source));\n  let radius = max(vec2<f32>(abs(expansion)), parameters.zw);\n  let stepUv = radius / max(dimensions, vec2<f32>(1.0));\n  let center = decode_coverage(textureSample(source, compositeSampler, uv), parameters.x);\n  if (max(radius.x, radius.y) < 0.001) { return center; }\n  let a = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, -stepUv.y)), parameters.x);\n  let b = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(0.0, -stepUv.y)), parameters.x);\n  let c = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, -stepUv.y)), parameters.x);\n  let d = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, 0.0)), parameters.x);\n  let e = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, 0.0)), parameters.x);\n  let f = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, stepUv.y)), parameters.x);\n  let g = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(0.0, stepUv.y)), parameters.x);\n  let h = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, stepUv.y)), parameters.x);\n  var expanded = center;\n  if (expansion > 0.001) { expanded = max(center, max(max(max(a, b), max(c, d)), max(max(e, f), max(g, h)))); }\n  if (expansion < -0.001) { expanded = min(center, min(min(min(a, b), min(c, d)), min(min(e, f), min(g, h)))); }\n  if (max(parameters.z, parameters.w) < 0.001) { return expanded; }\n  let blurred = (center * 2.0 + a + b + c + d + e + f + g + h) / 10.0;\n  return mix(expanded, blurred, clamp(max(parameters.z, parameters.w), 0.0, 1.0));\n}\n\nfn combine_coverage(current : f32, next : f32, operation : f32) -> f32 {\n  if (operation < 0.5) { return current + next * (1.0 - current); }\n  if (operation < 1.5) { return max(0.0, current - next); }\n  if (operation < 2.5) { return current * next; }\n  return abs(current - next);\n}\n\nfn gradient_offset(index : i32) -> f32 {\n  if (index < 4) { return object.gradientOffsets0[index]; }\n  return object.gradientOffsets1[index - 4];\n}\n\nfn gradient_color(position : vec2<f32>) -> vec4<f32> {\n  let start = object.gradientGeometry.xy;\n  let delta = object.gradientGeometry.zw - start;\n  var progress = dot(position - start, delta) / max(dot(delta, delta), 1e-6);\n  if (object.gradientParams.x > 1.5) { progress = length(position - start) / max(length(delta), 1e-6); }\n  progress = clamp(progress, 0.0, 1.0);\n  var previousOffset = gradient_offset(0);\n  var previousColor = object.gradientColors[0];\n  for (var index = 1; index < 8; index++) {\n    if (f32(index) >= object.gradientParams.y) { break; }\n    let nextOffset = gradient_offset(index);\n    let nextColor = object.gradientColors[index];\n    if (progress <= nextOffset) {\n      let local = clamp((progress - previousOffset) / max(nextOffset - previousOffset, 1e-6), 0.0, 1.0);\n      return mix(previousColor, nextColor, local) * vec4<f32>(1.0, 1.0, 1.0, object.gradientParams.z);\n    }\n    previousOffset = nextOffset;\n    previousColor = nextColor;\n  }\n  return previousColor * vec4<f32>(1.0, 1.0, 1.0, object.gradientParams.z);\n}\n\nfn effect_kind(index : u32) -> f32 {\n  if (index < 4u) { return object.effectKinds0[index]; }\n  return object.effectKinds1[index - 4u];\n}\n\nfn unpremultiply(value : vec4<f32>) -> vec4<f32> {\n  if (value.a <= 1e-6) { return vec4<f32>(0.0); }\n  return vec4<f32>(value.rgb / value.a, value.a);\n}\n\nfn apply_color_effect(value : vec4<f32>, index : u32) -> vec4<f32> {\n  let kind = effect_kind(index);\n  let data = object.effectData[index];\n  var color = unpremultiply(value);\n  if (kind < 1.5) {\n    let luminance = dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));\n    let tinted = mix(data.data0.xyz, vec3<f32>(data.data0.w, data.data1.x, data.data1.y), luminance);\n    color = vec4<f32>(mix(color.rgb, tinted, clamp(data.data1.z, 0.0, 1.0)), color.a);\n  } else if (kind < 2.5) {\n    color = vec4<f32>(data.data0.rgb, color.a);\n    color.a = color.a * data.data0.a * clamp(data.data1.x, 0.0, 1.0);\n  } else if (kind < 3.5) {\n    color.a = color.a * clamp(data.data0.x, 0.0, 1.0);\n  } else if (kind < 4.5) {\n    let source = color;\n    color = vec4<f32>(\n      dot(source, data.data0) + data.data1.x,\n      dot(source, vec4<f32>(data.data1.yzw, data.data2.x)) + data.data2.y,\n      dot(source, vec4<f32>(data.data2.zw, data.data3.xy)) + data.data3.z,\n      dot(source, vec4<f32>(data.data3.w, data.data4.xyz)) + data.data4.w\n    );\n    color = clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));\n  }\n  return vec4<f32>(color.rgb * color.a, color.a);\n}\n\nfn sample_blurred(uv : vec2<f32>, radius : vec2<f32>) -> vec4<f32> {\n  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));\n  let stepUv = radius / dimensions;\n  if (max(radius.x, radius.y) < 0.01) { return textureSampleLevel(baseTexture, baseSampler, uv, 0.0); }\n  var value = textureSampleLevel(baseTexture, baseSampler, uv, 0.0) * 0.25;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, 0.0), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, 0.0), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(0.0, -stepUv.y), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(0.0, stepUv.y), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, -stepUv.y), 0.0) * 0.0625;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, -stepUv.y), 0.0) * 0.0625;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, stepUv.y), 0.0) * 0.0625;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, stepUv.y), 0.0) * 0.0625;\n  return value;\n}\n\n@fragment\nfn fs_effect(input : EffectVertexOutput) -> @location(0) vec4<f32> {\n  let kind = effect_kind(input.effectIndex);\n  let data = object.effectData[input.effectIndex];\n  if (kind < 4.5) { return apply_color_effect(textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0), input.effectIndex); }\n  if (kind < 5.5) { return sample_blurred(input.uv, max(data.data0.xy, vec2<f32>(0.0))); }\n  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));\n  let shadowUv = input.uv - data.data1.yz / dimensions;\n  let shadowCoverage = sample_blurred(shadowUv, vec2<f32>(max(data.data1.w, 0.0))).a;\n  let shadowAlpha = clamp(shadowCoverage * data.data1.x * data.data0.a, 0.0, 1.0);\n  let shadow = vec4<f32>(data.data0.rgb * shadowAlpha, shadowAlpha);\n  let foreground = textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0);\n  return foreground + shadow * (1.0 - foreground.a);\n}\n\n@fragment\nfn fs_present(input : EffectVertexOutput) -> @location(0) vec4<f32> {\n  return textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0);\n}\n\n@fragment\nfn fs_main(input : VertexOutput) -> @location(0) vec4<f32> {\n  var base = textureSample(baseTexture, baseSampler, input.uv) * object.color;\n  if (object.gradientParams.x > 0.5) { base = gradient_color(input.localPosition) * object.color; }\n  var coverage = 1.0;\n  if (object.params.x > 0.5) {\n    let uv = input.clipPos.xy / vec2<f32>(textureDimensions(compositeTexture0));\n    coverage = select(0.0, 1.0, object.compositeParams[0].y > 0.5 && object.compositeParams[0].y < 2.5);\n    coverage = combine_coverage(coverage, filtered_coverage(compositeTexture0, uv, object.compositeParams[0], object.compositeExpansion0.x), object.compositeParams[0].y);\n    if (object.params.x > 1.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture1, uv, object.compositeParams[1], object.compositeExpansion0.y), object.compositeParams[1].y); }\n    if (object.params.x > 2.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture2, uv, object.compositeParams[2], object.compositeExpansion0.z), object.compositeParams[2].y); }\n    if (object.params.x > 3.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture3, uv, object.compositeParams[3], object.compositeExpansion0.w), object.compositeParams[3].y); }\n    if (object.params.x > 4.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture4, uv, object.compositeParams[4], object.compositeExpansion1.x), object.compositeParams[4].y); }\n    if (object.params.x > 5.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture5, uv, object.compositeParams[5], object.compositeExpansion1.y), object.compositeParams[5].y); }\n    if (object.params.x > 6.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture6, uv, object.compositeParams[6], object.compositeExpansion1.z), object.compositeParams[6].y); }\n    if (object.params.x > 7.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture7, uv, object.compositeParams[7], object.compositeExpansion1.w), object.compositeParams[7].y); }\n  }\n  return vec4<f32>(base.rgb, base.a * coverage);\n}\n";
+
+export { Animation2dWgsl as A };
+//# sourceMappingURL=2d-ui-animation-2d.generated-D4aHzFU2.js.map

package/dist/chunks/2d-ui-canvas-text-2d.generated-C0Eaej2m.js

@@ -0,0 +1,4 @@
+var CanvasText2dWgsl = "// haiyue:builtin-render canvas-text-2d\n// source: shader-language/builtin-components-2d-ui-family.json\n\nstruct CameraUniforms {\n  viewProj : mat4x4<f32>,\n}\n\nstruct ObjectUniforms {\n  model : mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> camera : CameraUniforms;\n@group(1) @binding(0) var<uniform> object : ObjectUniforms;\n@group(2) @binding(0) var textTexture : texture_2d<f32>;\n@group(2) @binding(1) var textSampler : sampler;\n\nstruct VertexInput {\n  @location(0) position : vec2<f32>,\n  @location(1) uv : vec2<f32>,\n}\n\nstruct VertexOutput {\n  @builtin(position) clipPos : vec4<f32>,\n  @location(0) uv : vec2<f32>,\n}\n\n@vertex\nfn vs_main(input : VertexInput) -> VertexOutput {\n  var out : VertexOutput;\n  out.clipPos = camera.viewProj * object.model * vec4<f32>(input.position, 0.0, 1.0);\n  out.uv = input.uv;\n  return out;\n}\n\n@fragment\nfn fs_main(input : VertexOutput) -> @location(0) vec4<f32> {\n  return textureSample(textTexture, textSampler, input.uv);\n}\n";
+
+export { CanvasText2dWgsl as C };
+//# sourceMappingURL=2d-ui-canvas-text-2d.generated-C0Eaej2m.js.map

package/dist/chunks/2d-ui-spine2d.generated-CUUi8xjl.js

@@ -0,0 +1,4 @@
+var spine2dWgsl = "// haiyue:builtin-render spine2d\n// source: shader-language/builtin-components-2d-ui-family.json\n\nstruct CameraUniforms {\n  viewProj : mat4x4<f32>,\n}\n\nstruct ObjectUniforms {\n  model : mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> camera : CameraUniforms;\n@group(1) @binding(0) var<uniform> object : ObjectUniforms;\n@group(2) @binding(0) var atlasTexture : texture_2d<f32>;\n@group(2) @binding(1) var atlasSampler : sampler;\n\nstruct VertexInput {\n  @location(0) position : vec2<f32>,\n  @location(1) uv : vec2<f32>,\n  @location(2) color : vec4<f32>,\n}\n\nstruct VertexOutput {\n  @builtin(position) clipPos : vec4<f32>,\n  @location(0) uv : vec2<f32>,\n  @location(1) color : vec4<f32>,\n}\n\n@vertex\nfn vs_main(input : VertexInput) -> VertexOutput {\n  var out : VertexOutput;\n  out.clipPos = camera.viewProj * object.model * vec4<f32>(input.position, 0.0, 1.0);\n  out.uv = input.uv;\n  out.color = input.color;\n  return out;\n}\n\n@fragment\nfn fs_main(input : VertexOutput) -> @location(0) vec4<f32> {\n  return textureSample(atlasTexture, atlasSampler, input.uv) * input.color;\n}\n";
+
+export { spine2dWgsl as s };
+//# sourceMappingURL=2d-ui-spine2d.generated-CUUi8xjl.js.map

package/dist/chunks/2d-ui-tilemap2d.generated-gebw4mX7.js

@@ -0,0 +1,4 @@
+var tilemap2dWgsl = "// haiyue:builtin-render tilemap2d\n// source: shader-language/builtin-components-2d-ui-family.json\n\nstruct CameraUniforms {\n  viewProj : mat4x4<f32>,\n}\n\nstruct ObjectUniforms {\n  model : mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> camera : CameraUniforms;\n@group(1) @binding(0) var<uniform> object : ObjectUniforms;\n\nstruct VertexInput {\n  @location(0) position : vec2<f32>,\n  @location(1) color : vec4<f32>,\n}\n\nstruct VertexOutput {\n  @builtin(position) clipPos : vec4<f32>,\n  @location(0) color : vec4<f32>,\n}\n\n@vertex\nfn vs_main(input : VertexInput) -> VertexOutput {\n  var out : VertexOutput;\n  out.clipPos = camera.viewProj * object.model * vec4<f32>(input.position, 0.0, 1.0);\n  out.color = input.color;\n  return out;\n}\n\n@fragment\nfn fs_main(input : VertexOutput) -> @location(0) vec4<f32> {\n  return input.color;\n}\n";
+
+export { tilemap2dWgsl as t };
+//# sourceMappingURL=2d-ui-tilemap2d.generated-gebw4mX7.js.map