@haiyue/extensions 0.1.0

package/dist/gltf.d.ts

@@ -0,0 +1,12 @@
+export { GltfModelComponent } from './gltf/GltfModelComponent';
+export type { GltfModelComponentOptions, GltfModelStatus } from './gltf/GltfModelComponent';
+export { GltfModelSystem } from './gltf/GltfModelSystem';
+export type { GltfModelSystemOptions } from './gltf/GltfModelSystem';
+export { applyGltfAnimationClip, disposeGltfModel, GLTF_EXTENSION_CAPABILITIES, loadGltfModel, setGltfMaterialVariant } from './gltf/gltfLoader';
+export { DEFAULT_GLTF_EXTENSION_ADAPTERS, collectGltfMaterialExtensionPatches, collectGltfMaterialVariantNames, collectGltfMaterialVariantReferences, resolveGltfExtensionAdapters, } from './gltf/GltfExtensionAdapter';
+export { encodeGltfPbrMaterial } from './gltf/GltfMaterialEncoder';
+export type { EncodedGltfPbrMaterial, EncodeGltfPbrMaterialOptions, } from './gltf/GltfMaterialEncoder';
+export type { DracoDecoderConfig, DracoDecoderFactory, DracoDecoderModule, GltfAssetWorker, GltfAnimationClip, GltfAnimationInfo, GltfAnimationInterpolation, GltfAnimationPath, GltfAssetStats, GltfExtensionCapability, GltfExtensionAdapter, GltfExtensionReport, GltfExtensionReportEntry, GltfExtensionSupport, GltfLoadWarning, GltfCompatibilityExtensionEntry, GltfCompatibilityIssue, GltfCompatibilityPerformanceSummary, GltfCompatibilityReport, GltfCompatibilityStatus, GltfPrimitiveBoundsCompatibilityEntry, GltfPrimitiveBoundsSupport, GltfPrimitiveUvSemanticCompatibilityEntry, GltfTextureCompatibilityEntry, GltfTextureMipmapSource, LoadedGltfModel, LoadGltfOptions, } from './gltf/gltfLoader';
+export type { GltfMaterialExtensionContext, GltfMaterialExtensionPatch, GltfMaterialStatePatch, GltfMaterialTextureBinding, GltfMaterialVariantReference, GltfPrimitiveExtensionContext, } from './gltf/GltfExtensionAdapter';
+export { createGltfPlugin } from './gltf/GltfPlugin';
+export type { GltfPluginOptions } from './gltf/GltfPlugin';

package/dist/gltf.js

@@ -0,0 +1,517 @@
+import { Component, System } from '@haiyue/engine';
+import { UniqueCheckType } from '@haiyue/engine/ecs';
+import { AssetJob } from '@haiyue/engine/assets';
+import { a as loadGltfModel, d as disposeGltfModel } from './chunks/gltfLoader-Dm22jLYB.js';
+export { D as DEFAULT_GLTF_EXTENSION_ADAPTERS, G as GLTF_EXTENSION_CAPABILITIES, c as collectGltfMaterialExtensionPatches, b as collectGltfMaterialVariantNames, e as collectGltfMaterialVariantReferences, r as resolveGltfExtensionAdapters, s as setGltfMaterialVariant } from './chunks/gltfLoader-Dm22jLYB.js';
+import { E as EXTENSIONS_PLUGIN_VERSION, o as ownedEditorViewportSystem, r as removeSystem } from './chunks/pluginUtils-CvwroRMd.js';
+export { a as applyGltfAnimationClip } from './chunks/GltfAnimationRuntime-CRHsLycN.js';
+import '@haiyue/engine/components';
+import '@haiyue/engine/experimental/async';
+import 'wgpu-matrix';
+import '@haiyue/engine/material';
+import '@haiyue/engine/core';
+
+class GltfModelComponent extends Component {
+    static UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+    static UniqueSymbol = Symbol.for('GltfModelComponent');
+    static editor = {
+        fields: {
+            src: {
+                type: 'asset-ref',
+                label: 'Source',
+                assetType: 'gltf',
+                placeholder: 'glTF / GLB URL or asset key',
+                validate: (value) => String(value ?? '').trim() ? null : 'Source is required.',
+            },
+            scene: {
+                type: 'number',
+                label: 'Scene Index',
+                min: 0,
+                step: 1,
+                visibleWhen: (component) => String(component.src).trim().length > 0,
+            },
+            autoLoad: { type: 'boolean', label: 'Auto Load' },
+            clearPrevious: { type: 'boolean', label: 'Clear Previous' },
+            baseColorFactor: {
+                type: 'array',
+                label: 'Fallback Color',
+                rows: 2,
+                validate: (value) => Array.isArray(value) && value.length === 4 ? null : 'Fallback Color must be [r, g, b, a].',
+            },
+        },
+    };
+    _src = '';
+    _scene = null;
+    _sourceKey = '|';
+    _sourceKeyDirty = false;
+    autoLoad;
+    clearPrevious;
+    baseColorFactor;
+    status = 'idle';
+    error = null;
+    /** Runtime root inserted by GltfModelSystem. Do not serialize. */
+    runtimeRoot = null;
+    runtimeAnimations = [];
+    runtimeAnimationClips = [];
+    runtimeAssetStats = null;
+    runtimeCompatibilityReport = null;
+    runtimeMaterialVariants = [];
+    runtimeSourceKey = '';
+    loadingSourceKey = '';
+    constructor(options = {}) {
+        super('GltfModelComponent');
+        this.src = options.src ?? '';
+        this.scene = options.scene ?? null;
+        this.autoLoad = options.autoLoad ?? true;
+        this.clearPrevious = options.clearPrevious ?? true;
+        this.baseColorFactor = options.baseColorFactor
+            ? [...options.baseColorFactor]
+            : [1, 1, 1, 1];
+    }
+    get src() {
+        return this._src;
+    }
+    set src(value) {
+        if (this._src === value)
+            return;
+        this._src = value;
+        this._sourceKeyDirty = true;
+    }
+    get scene() {
+        return this._scene;
+    }
+    set scene(value) {
+        if (this._scene === value)
+            return;
+        this._scene = value;
+        this._sourceKeyDirty = true;
+    }
+    get sourceKey() {
+        if (this._sourceKeyDirty) {
+            this._sourceKey = `${this._src}|${this._scene ?? ''}`;
+            this._sourceKeyDirty = false;
+        }
+        return this._sourceKey;
+    }
+    clone() {
+        return new GltfModelComponent({
+            src: this.src,
+            ...(this.scene === null ? {} : { scene: this.scene }),
+            autoLoad: this.autoLoad,
+            clearPrevious: this.clearPrevious,
+            baseColorFactor: this.baseColorFactor,
+        });
+    }
+}
+
+class GltfModelSystem extends System {
+    dracoDecoder;
+    dracoDecoderConfig;
+    loadTimeoutMs;
+    assetManager;
+    assetWorker;
+    assetPriority;
+    componentModels = new Map();
+    pendingLoads = new Map();
+    failedLoads = new Map();
+    liveComponents = new Set();
+    constructor(options = {}) {
+        super({ all: [GltfModelComponent] });
+        this.name = 'GltfModelSystem';
+        if (options.priority !== undefined)
+            this.priority = options.priority;
+        this.dracoDecoder = options.dracoDecoder ?? null;
+        this.dracoDecoderConfig = options.dracoDecoderConfig;
+        this.loadTimeoutMs = Math.max(0, options.loadTimeoutMs ?? 30000);
+        this.assetManager = options.assetManager ?? null;
+        this.assetWorker = options.assetWorker ?? null;
+        this.assetPriority = options.assetPriority ?? 'normal';
+    }
+    update(world, _time, _delta) {
+        this.liveComponents.clear();
+        const entities = this.entitySet.get(world);
+        if (entities)
+            for (const entity of entities) {
+                const component = entity.getComponent(GltfModelComponent);
+                if (!component)
+                    continue;
+                this.liveComponents.add(component);
+                if (!component.autoLoad || !component.src)
+                    continue;
+                const key = component.sourceKey;
+                if (component.runtimeSourceKey === key
+                    || component.loadingSourceKey === key
+                    || this.failedLoads.get(component) === key)
+                    continue;
+                this.loadIntoEntity(entity, component, key);
+            }
+        this.releaseModelsNotIn(this.liveComponents);
+        this.abortLoadsNotIn(this.liveComponents);
+        this.releaseFailuresNotIn(this.liveComponents);
+        return this;
+    }
+    destroy() {
+        for (const component of [...this.pendingLoads.keys()])
+            this.abortPendingLoad(component);
+        this.disposeAllModels();
+        this.failedLoads.clear();
+        return super.destroy();
+    }
+    async loadIntoEntity(entity, component, key) {
+        this.abortPendingLoad(component);
+        component.status = 'loading';
+        component.error = null;
+        component.loadingSourceKey = key;
+        this.failedLoads.delete(component);
+        component.runtimeAnimations = [];
+        component.runtimeAnimationClips = [];
+        component.runtimeAssetStats = null;
+        component.runtimeCompatibilityReport = null;
+        component.runtimeMaterialVariants = [];
+        const pending = this.createPendingLoad(component, key);
+        try {
+            const model = await pending.job.start(async (context) => {
+                context.setPhase('parsing');
+                return await loadGltfModel(component.src, {
+                    scene: component.scene,
+                    baseColorFactor: component.baseColorFactor,
+                    dracoDecoder: this.dracoDecoder,
+                    ...(this.dracoDecoderConfig === undefined ? {} : { dracoDecoderConfig: this.dracoDecoderConfig }),
+                    assetManager: this.assetManager,
+                    assetWorker: this.assetWorker,
+                    signal: context.signal,
+                });
+            });
+            if (component.loadingSourceKey !== key) {
+                disposeGltfModel(model);
+                return;
+            }
+            if (component.clearPrevious) {
+                if (component.runtimeRoot)
+                    entity.removeChild(component.runtimeRoot);
+                this.disposeModelsForComponent(component);
+            }
+            model.root.name = `${entity.name || 'glTF'} Model`;
+            entity.addChild(model.root);
+            this.trackModel(component, model);
+            component.runtimeRoot = model.root;
+            component.runtimeAnimations = model.animations;
+            component.runtimeAnimationClips = model.animationClips;
+            component.runtimeAssetStats = model.assetStats;
+            component.runtimeCompatibilityReport = model.compatibilityReport;
+            component.runtimeMaterialVariants = model.materialVariants;
+            component.runtimeSourceKey = key;
+            this.failedLoads.delete(component);
+            component.status = 'loaded';
+        }
+        catch (error) {
+            const timedOut = String(pending.job.controller.signal.reason ?? '').startsWith('timeout:');
+            if (component.loadingSourceKey !== key || (pending.job.controller.signal.aborted && !timedOut)) {
+                if (component.loadingSourceKey === key)
+                    component.loadingSourceKey = '';
+                return;
+            }
+            component.status = 'error';
+            this.failedLoads.set(component, key);
+            component.error = timedOut
+                ? `glTF load timed out after ${this.loadTimeoutMs}ms.`
+                : error instanceof Error ? error.message : String(error);
+            console.warn(`[GltfModelSystem] ${component.error}`, error);
+        }
+        finally {
+            this.clearPendingLoad(component, pending);
+            if (component.loadingSourceKey === key)
+                component.loadingSourceKey = '';
+        }
+    }
+    createPendingLoad(component, key) {
+        const pending = {
+            key,
+            job: new AssetJob(`gltf:${key}`, {
+                timeoutMs: this.loadTimeoutMs,
+                priority: this.assetPriority,
+                disposeLateResult: disposeGltfModel,
+            }),
+        };
+        this.pendingLoads.set(component, pending);
+        return pending;
+    }
+    clearPendingLoad(component, pending) {
+        if (this.pendingLoads.get(component) === pending)
+            this.pendingLoads.delete(component);
+    }
+    abortPendingLoad(component) {
+        const pending = this.pendingLoads.get(component);
+        if (!pending)
+            return;
+        pending.job.abort('component-removed');
+        this.pendingLoads.delete(component);
+        if (component.loadingSourceKey === pending.key)
+            component.loadingSourceKey = '';
+    }
+    trackModel(component, model) {
+        let models = this.componentModels.get(component);
+        if (!models) {
+            models = new Set();
+            this.componentModels.set(component, models);
+        }
+        models.add(model);
+    }
+    disposeModelsForComponent(component) {
+        const models = this.componentModels.get(component);
+        if (!models)
+            return;
+        for (const model of models)
+            disposeGltfModel(model);
+        models.clear();
+        this.componentModels.delete(component);
+    }
+    releaseModelsNotIn(liveComponents) {
+        for (const component of [...this.componentModels.keys()]) {
+            if (!liveComponents.has(component)) {
+                this.disposeModelsForComponent(component);
+                component.runtimeRoot = null;
+                component.runtimeAnimations = [];
+                component.runtimeAnimationClips = [];
+                component.runtimeAssetStats = null;
+                component.runtimeCompatibilityReport = null;
+                component.runtimeMaterialVariants = [];
+                component.runtimeSourceKey = '';
+            }
+        }
+    }
+    abortLoadsNotIn(liveComponents) {
+        for (const component of [...this.pendingLoads.keys()]) {
+            if (!liveComponents.has(component))
+                this.abortPendingLoad(component);
+        }
+    }
+    releaseFailuresNotIn(liveComponents) {
+        for (const component of this.failedLoads.keys()) {
+            if (!liveComponents.has(component))
+                this.failedLoads.delete(component);
+        }
+    }
+    disposeAllModels() {
+        for (const component of [...this.componentModels.keys()])
+            this.disposeModelsForComponent(component);
+    }
+}
+
+/**
+ * Encodes the standard glTF material portion without taking ownership of image,
+ * sampler, or buffer allocation. Scene exporters can share this codec instead
+ * of duplicating KHR material semantics.
+ */
+function encodeGltfPbrMaterial(material, options) {
+    const extensionsUsed = new Set();
+    const texture = (slot, source) => {
+        if (!source)
+            return undefined;
+        const index = options.resolveTextureIndex(slot, source);
+        if (!Number.isSafeInteger(index) || index < 0) {
+            throw new RangeError(`glTF texture index for PBR slot "${slot}" must be a non-negative safe integer.`);
+        }
+        return encodeTextureInfo(material, slot, index, extensionsUsed);
+    };
+    const baseColor = new Float32Array(4);
+    material.baseColor.writeLinear(baseColor);
+    const baseColorTexture = texture('baseColor', material.baseColorTexture);
+    const metallicRoughnessTexture = texture('metallicRoughness', material.metallicRoughnessTexture);
+    const normalTexture = texture('normal', material.normalTexture);
+    const occlusionTexture = texture('occlusion', material.occlusionTexture);
+    const emissiveTexture = texture('emissive', material.emissiveTexture);
+    const clearcoatTexture = texture('clearcoat', material.clearcoatTexture);
+    const clearcoatRoughnessTexture = texture('clearcoatRoughness', material.clearcoatRoughnessTexture);
+    const clearcoatNormalTexture = texture('clearcoatNormal', material.clearcoatNormalTexture);
+    const specularTexture = texture('specular', material.specularTexture);
+    const specularColorTexture = texture('specularColor', material.specularColorTexture);
+    const sheenColorTexture = texture('sheenColor', material.sheenColorTexture);
+    const sheenRoughnessTexture = texture('sheenRoughness', material.sheenRoughnessTexture);
+    const transmissionTexture = texture('transmission', material.transmissionTexture);
+    const thicknessTexture = texture('thickness', material.thicknessTexture);
+    const extensions = {};
+    if (material.clearcoatFactor !== 0
+        || material.clearcoatRoughnessFactor !== 0
+        || clearcoatTexture
+        || clearcoatRoughnessTexture
+        || clearcoatNormalTexture) {
+        extensions.KHR_materials_clearcoat = {
+            clearcoatFactor: material.clearcoatFactor,
+            ...(clearcoatTexture ? { clearcoatTexture } : {}),
+            clearcoatRoughnessFactor: material.clearcoatRoughnessFactor,
+            ...(clearcoatRoughnessTexture ? { clearcoatRoughnessTexture } : {}),
+            ...(clearcoatNormalTexture ? {
+                clearcoatNormalTexture: { ...clearcoatNormalTexture, scale: material.clearcoatNormalScale },
+            } : {}),
+        };
+        extensionsUsed.add('KHR_materials_clearcoat');
+    }
+    if (material.ior !== 1.5) {
+        extensions.KHR_materials_ior = { ior: material.ior };
+        extensionsUsed.add('KHR_materials_ior');
+    }
+    if (material.specularFactor !== 1
+        || material.specularColorFactor.some(channel => channel !== 1)
+        || specularTexture
+        || specularColorTexture) {
+        extensions.KHR_materials_specular = {
+            specularFactor: material.specularFactor,
+            ...(specularTexture ? { specularTexture } : {}),
+            specularColorFactor: [...material.specularColorFactor],
+            ...(specularColorTexture ? { specularColorTexture } : {}),
+        };
+        extensionsUsed.add('KHR_materials_specular');
+    }
+    if (material.sheenColorFactor.some(channel => channel !== 0)
+        || material.sheenRoughnessFactor !== 0
+        || sheenColorTexture
+        || sheenRoughnessTexture) {
+        extensions.KHR_materials_sheen = {
+            sheenColorFactor: [...material.sheenColorFactor],
+            ...(sheenColorTexture ? { sheenColorTexture } : {}),
+            sheenRoughnessFactor: material.sheenRoughnessFactor,
+            ...(sheenRoughnessTexture ? { sheenRoughnessTexture } : {}),
+        };
+        extensionsUsed.add('KHR_materials_sheen');
+    }
+    if (material.transmissionFactor !== 0 || transmissionTexture) {
+        extensions.KHR_materials_transmission = {
+            transmissionFactor: material.transmissionFactor,
+            ...(transmissionTexture ? { transmissionTexture } : {}),
+        };
+        extensionsUsed.add('KHR_materials_transmission');
+    }
+    if (material.thicknessFactor !== 0
+        || thicknessTexture
+        || material.attenuationDistance !== Infinity
+        || material.attenuationColor.some(channel => channel !== 1)) {
+        extensions.KHR_materials_volume = {
+            thicknessFactor: material.thicknessFactor,
+            ...(thicknessTexture ? { thicknessTexture } : {}),
+            ...(material.attenuationDistance === Infinity ? {} : { attenuationDistance: material.attenuationDistance }),
+            attenuationColor: [...material.attenuationColor],
+        };
+        extensionsUsed.add('KHR_materials_volume');
+        if (material.transmissionFactor === 0 && !transmissionTexture) {
+            extensions.KHR_materials_transmission = { transmissionFactor: 0 };
+            extensionsUsed.add('KHR_materials_transmission');
+        }
+    }
+    const gltfMaterial = {
+        ...(options.name ? { name: options.name } : {}),
+        pbrMetallicRoughness: {
+            baseColorFactor: [baseColor[0], baseColor[1], baseColor[2], baseColor[3]],
+            ...(baseColorTexture ? { baseColorTexture } : {}),
+            ...(metallicRoughnessTexture ? { metallicRoughnessTexture } : {}),
+            metallicFactor: material.metallic,
+            roughnessFactor: material.roughness,
+        },
+        emissiveFactor: [...material.emissiveFactor],
+        ...(emissiveTexture ? { emissiveTexture } : {}),
+        ...(normalTexture ? { normalTexture: { ...normalTexture, scale: material.normalScale } } : {}),
+        ...(occlusionTexture ? { occlusionTexture: { ...occlusionTexture, strength: material.occlusionStrength } } : {}),
+        alphaMode: material.alphaMode === 'blend' ? 'BLEND' : material.alphaMode === 'mask' ? 'MASK' : 'OPAQUE',
+        ...(material.alphaMode === 'mask' ? { alphaCutoff: material.alphaCutoff } : {}),
+        doubleSided: material.doubleSided,
+        ...(Object.keys(extensions).length > 0 ? { extensions } : {}),
+    };
+    return Object.freeze({
+        material: gltfMaterial,
+        extensionsUsed: Object.freeze([...extensionsUsed]),
+    });
+}
+function encodeTextureInfo(material, slot, index, extensionsUsed) {
+    const mapping = material.getTextureMapping(slot);
+    const transform = {};
+    if (mapping.offset[0] !== 0 || mapping.offset[1] !== 0)
+        transform.offset = [...mapping.offset];
+    if (mapping.rotation !== 0)
+        transform.rotation = mapping.rotation;
+    if (mapping.scale[0] !== 1 || mapping.scale[1] !== 1)
+        transform.scale = [...mapping.scale];
+    const transformed = Object.keys(transform).length > 0;
+    if (transformed)
+        extensionsUsed.add('KHR_texture_transform');
+    return {
+        index,
+        ...(mapping.texCoord !== 0 ? { texCoord: mapping.texCoord } : {}),
+        ...(transformed ? { extensions: { KHR_texture_transform: transform } } : {}),
+    };
+}
+
+function createGltfPlugin(options = {}) {
+    let system = null;
+    return {
+        name: '@haiyue/extensions/gltf',
+        version: EXTENSIONS_PLUGIN_VERSION,
+        installEngine(context) {
+            context.registerComponent({ type: 'GltfModelComponent', component: GltfModelComponent });
+        },
+        installScene(context) {
+            context.registerComponent({ type: 'GltfModelComponent', component: GltfModelComponent });
+            system = new GltfModelSystem({
+                ...options.system,
+                assetManager: options.system?.assetManager ?? context.assetManager ?? null,
+            });
+            context.addSystem(system, false);
+        },
+        uninstallScene(context) {
+            removeSystem(context, system);
+            system = null;
+        },
+        installEditor(context) {
+            context.registerContribution({ components: [{
+                        type: 'GltfModelComponent',
+                        create: () => new GltfModelComponent({ src: '', autoLoad: true }),
+                        inspector: GltfModelComponent.editor,
+                        serialize(component) {
+                            return {
+                                type: 'GltfModelComponent',
+                                src: component.src,
+                                scene: component.scene,
+                                autoLoad: component.autoLoad,
+                                clearPrevious: component.clearPrevious,
+                                baseColorFactor: [...component.baseColorFactor],
+                            };
+                        },
+                        deserialize(data) {
+                            const value = data;
+                            if (value.type !== 'GltfModelComponent')
+                                return null;
+                            return new GltfModelComponent({ ...value, ...(typeof value.scene === 'number' ? { scene: value.scene } : {}) });
+                        },
+                        clone: (component) => component.clone(),
+                        getIgnoredChildren: (component) => component.runtimeRoot ? [component.runtimeRoot] : [],
+                        collectDependencies(component, dependencyContext) {
+                            const dependency = dependencyContext.resolveModelBySrc(component.src);
+                            return dependency ? [dependency] : [];
+                        },
+                        collectSerializedDependencies(data, dependencyContext) {
+                            const value = data;
+                            const dependency = value.type === 'GltfModelComponent' && typeof value.src === 'string'
+                                ? dependencyContext.resolveModelBySrc(value.src)
+                                : null;
+                            return dependency ? [dependency] : [];
+                        },
+                        installViewport(viewport) {
+                            const existing = viewport.world.getSystem(GltfModelSystem);
+                            const viewportSystem = existing ?? new GltfModelSystem({ priority: 0 });
+                            if (!existing)
+                                viewport.world.addSystem(viewportSystem);
+                            return ownedEditorViewportSystem(viewport.world, viewportSystem, existing === null);
+                        },
+                        runtimeExport: {
+                            imports: [{ from: '@haiyue/extensions/gltf', names: ['GltfModelComponent', 'GltfModelSystem'] }],
+                            systems: ['GltfModelSystem'],
+                            deserializeExpression: 'new GltfModelComponent(data)',
+                            installSystems: '  if (hasComponentType(world, GltfModelComponent)) world.addSystem(new GltfModelSystem({ priority: 0 }));',
+                            has3D: true,
+                        },
+                    }] });
+        },
+    };
+}
+
+export { GltfModelComponent, GltfModelSystem, createGltfPlugin, disposeGltfModel, encodeGltfPbrMaterial, loadGltfModel };
+//# sourceMappingURL=gltf.js.map

package/dist/grid/Grid2DComponent.d.ts

@@ -0,0 +1,25 @@
+import { Component } from '@haiyue/engine';
+export interface Grid2DComponentOptions {
+    columns?: number;
+    rows?: number;
+    cellWidth?: number;
+    cellHeight?: number;
+    originX?: number;
+    originY?: number;
+}
+export declare class Grid2DComponent extends Component {
+    static UniqueCheckType: number;
+    static UniqueSymbol: symbol;
+    columns: number;
+    rows: number;
+    cellWidth: number;
+    cellHeight: number;
+    originX: number;
+    originY: number;
+    constructor(options?: Grid2DComponentOptions);
+    gridToWorld(column: number, row: number): [number, number];
+    gridToWorldCenter(column: number, row: number): [number, number];
+    worldToGrid(x: number, y: number): [number, number];
+    contains(column: number, row: number): boolean;
+    clone(): Grid2DComponent;
+}

package/dist/grid.d.ts

@@ -0,0 +1,2 @@
+export { Grid2DComponent } from './grid/Grid2DComponent';
+export type { Grid2DComponentOptions } from './grid/Grid2DComponent';

package/dist/grid.js

@@ -0,0 +1,56 @@
+import { Component } from '@haiyue/engine';
+import { UniqueCheckType } from '@haiyue/engine/ecs';
+
+class Grid2DComponent extends Component {
+    static UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+    static UniqueSymbol = Symbol.for('Grid2DComponent');
+    columns;
+    rows;
+    cellWidth;
+    cellHeight;
+    originX;
+    originY;
+    constructor(options = {}) {
+        super('Grid2DComponent');
+        this.columns = Math.max(1, Math.floor(options.columns ?? 10));
+        this.rows = Math.max(1, Math.floor(options.rows ?? 20));
+        this.cellWidth = options.cellWidth ?? 32;
+        this.cellHeight = options.cellHeight ?? 32;
+        this.originX = options.originX ?? 0;
+        this.originY = options.originY ?? 0;
+    }
+    gridToWorld(column, row) {
+        return [
+            this.originX + column * this.cellWidth,
+            this.originY + row * this.cellHeight,
+        ];
+    }
+    gridToWorldCenter(column, row) {
+        return [
+            this.originX + (column + 0.5) * this.cellWidth,
+            this.originY + (row + 0.5) * this.cellHeight,
+        ];
+    }
+    worldToGrid(x, y) {
+        return [
+            Math.floor((x - this.originX) / this.cellWidth),
+            Math.floor((y - this.originY) / this.cellHeight),
+        ];
+    }
+    contains(column, row) {
+        return column >= 0 && row >= 0 && column < this.columns && row < this.rows;
+    }
+    clone() {
+        return new Grid2DComponent({
+            columns: this.columns,
+            rows: this.rows,
+            cellWidth: this.cellWidth,
+            cellHeight: this.cellHeight,
+            originX: this.originX,
+            originY: this.originY,
+        });
+    }
+}
+
+export { Grid2DComponent };
+//# sourceMappingURL=grid.js.map

package/dist/hya-state-machine.d.ts

@@ -0,0 +1,7 @@
+export { Animation2DStateMachineComponent } from './animation/Animation2DStateMachineComponent';
+export type { Animation2DStateMachineComponentOptions } from './animation/Animation2DStateMachineComponent';
+export { Animation2DStateMachineSystem } from './animation/Animation2DStateMachineSystem';
+export type { Animation2DStateMachineSystemOptions } from './animation/Animation2DStateMachineSystem';
+export { createHyaAnimation2DClips, getHyaStateMachineExtension, } from './animation/HyaAnimation2DClipAdapter';
+export { AnimationStateMachineChannelError, assertAudioStateMachineCompatible, audioStateMachineCompatibilityDiagnostic, hyaStateMachineChannelCapability, HYA_STATE_MACHINE_CHANNEL_REGISTRY, } from './animation-state-machine/AnimationStateMachineChannels';
+export type { AnimationStateMachineChannelDiagnostic, AnimationStateMachineChannelDiagnosticCode, } from './animation-state-machine/AnimationStateMachineChannels';