@galacean/engine-spine 1.2.0 → 2.0.0-alpha.52

package/package.json

@@ -1,64 +1,39 @@
 {
-  "version": "1.2.0",
-  "description": "galacean spine runtime",
   "name": "@galacean/engine-spine",
+  "version": "2.0.0-alpha.52",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "url": "https://github.com/galacean/engine.git"
+  },
+  "license": "MIT",
   "main": "dist/main.js",
-  "browser": "dist/browser.js",
   "module": "dist/module.js",
-  "dependencies": {},
-  "peerDependencies": {
-    "@galacean/engine": ">=1.1.0-beta.0"
+  "debug": "src/index.ts",
+  "browser": "dist/browser.js",
+  "types": "types/index.d.ts",
+  "umd": {
+    "name": "Galacean.Spine",
+    "globals": {
+      "@galacean/engine": "Galacean"
+    }
   },
+  "files": [
+    "dist/**/*",
+    "types/**/*"
+  ],
   "devDependencies": {
-    "@babel/core": "^7.22.5",
-    "@babel/plugin-proposal-class-properties": "^7.12.1",
-    "@babel/plugin-proposal-decorators": "^7.12.1",
-    "@babel/plugin-proposal-optional-chaining": "^7.12.1",
-    "@babel/plugin-transform-object-assign": "^7.12.1",
-    "@babel/preset-env": "^7.12.1",
-    "@babel/preset-typescript": "^7.12.1",
-    "@galacean/engine": "^1.1.0-beta.11",
-    "@galacean/engine-toolkit": "^1.1.0-beta.0",
-    "@rollup/plugin-babel": "^5.2.1",
-    "@rollup/plugin-commonjs": "^16.0.0",
-    "@rollup/plugin-inject": "^4.0.2",
-    "@rollup/plugin-node-resolve": "^10.0.0",
-    "@rollup/plugin-replace": "^2.3.4",
-    "@rollup/plugin-terser": "^0.4.3",
-    "@swc/core": "^1.3.32",
-    "@swc/helpers": "^0.5",
-    "cross-env": "^5.2.0",
-    "dat.gui": "^0.7.9",
-    "react": "^16.14.0",
-    "react-dom": "^16.14.0",
-    "rollup": "^2.32.0",
-    "rollup-plugin-glslify": "^1.2.0",
-    "rollup-plugin-modify": "^3.0.0",
-    "rollup-plugin-serve": "^1.1.0",
-    "rollup-plugin-swc3": "^0.8.0",
-    "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-version-injector": "^1.3.3",
-    "typescript": "^4.8.4",
-    "vite": "^4.3.9"
+    "@galacean/engine": "2.0.0-alpha.52"
   },
-  "ci": {
-    "type": "aci",
-    "versions": "12"
+  "peerDependencies": {
+    "@galacean/engine": "2.0.0-alpha.52"
   },
-  "files": [
-    "types",
-    "dist"
-  ],
-  "scripts": {
-    "example": "vite",
-    "test": "jest",
-    "test-cov": "jest --coverage",
-    "dev": "rollup -cw",
-    "build": "npm run b:types && cross-env BUILD_TYPE=ALL rollup -c",
-    "ci": "npm run lint && npm run test-cov",
-    "lint": "eslint src --fix --ext .ts,.tsx",
-    "b:types": "tsc --emitDeclarationOnly"
+  "dependencies": {
+    "@galacean/engine-design": "2.0.0-alpha.52"
   },
-  "types": "types/index.d.ts",
-  "repository": "https://github.com/johanzhu/engine-spine.git"
-}
+  "scripts": {
+    "b:types": "tsc"
+  }
+}

package/types/SpineAnimation.d.ts

@@ -1,45 +1,5 @@
-import { Skeleton } from "./spine-core/Skeleton";
-import { SkeletonData } from "./spine-core/SkeletonData";
-import { AnimationState } from "./spine-core/AnimationState";
-import { MeshGenerator } from "./core/MeshGenerator";
-import { SpineRenderSetting } from "./types";
-import { Script, Entity, Texture2D, Material, Engine } from "@galacean/engine";
-export declare class SpineAnimation extends Script {
-    /** Spine 材质 */
-    private static _defaultMaterial;
-    static getDefaultMaterial(engine: Engine): Material;
-    private _skeletonData;
-    private _skeleton;
-    private _state;
-    private _tempOffset;
-    private _tempSize;
-    private _tempArray;
-    protected _meshGenerator: MeshGenerator;
-    setting: SpineRenderSetting;
-    autoUpdateBounds: boolean;
-    noPause: boolean;
-    get skeletonData(): SkeletonData;
-    get skeleton(): Skeleton;
-    get state(): AnimationState;
-    get mesh(): import("@galacean/engine").BufferMesh;
-    set scale(v: number);
-    constructor(entity: Entity);
-    setSkeletonData(skeletonData: SkeletonData, setting?: SpineRenderSetting): void;
-    /**
-     * Separate slot by slot name. This will add a new sub mesh, and new materials.
-     */
-    addSeparateSlot(slotName: string): void;
-    /**
-     * Change texture of a separated slot by name.
-     */
-    hackSeparateSlotTexture(slotName: string, texture: Texture2D): void;
-    onUpdate(delta: number): void;
-    updateGeometry(): void;
-    updateBounds(): void;
-    /**
-     * Spine animation custom clone.
-     */
-    _cloneTo(target: SpineAnimation): void;
-    private _disposeCurrentSkeleton;
-    onDestroy(): void;
+/** Read-only animation metadata shared by instances of a resource. */
+export interface SpineAnimation {
+    readonly name: string;
+    readonly duration: number;
 }

package/types/SpineAnimationState.d.ts

@@ -0,0 +1,32 @@
+import type { SpineAnimationStateData } from "./SpineAnimationStateData";
+import type { SpineAnimationStateListener } from "./SpineAnimationStateListener";
+import { SpineTrackEntry } from "./SpineTrackEntry";
+/** Playback controls for one renderer. Entries and callback arguments have stable public identities. */
+export declare class SpineAnimationState {
+    private _native;
+    private _runtime;
+    readonly data: SpineAnimationStateData;
+    private _entries;
+    private _listeners;
+    private _operationDepth;
+    private _disposed;
+    private constructor();
+    get timeScale(): number;
+    set timeScale(value: number);
+    setAnimation(track: number, name: string, loop: boolean): SpineTrackEntry;
+    addAnimation(track: number, name: string, loop: boolean, delay: number): SpineTrackEntry;
+    setEmptyAnimation(track: number, mixDuration: number): SpineTrackEntry;
+    addEmptyAnimation(track: number, mixDuration: number, delay: number): SpineTrackEntry;
+    setEmptyAnimations(mixDuration: number): void;
+    getCurrent(track: number): SpineTrackEntry | null;
+    clearTrack(track: number): void;
+    clearTracks(): void;
+    addListener(listener: SpineAnimationStateListener): void;
+    removeListener(listener: SpineAnimationStateListener): void;
+    clearListeners(): void;
+    private _validateTrack;
+    private _command;
+    private _endOperation;
+    private _dispatch;
+    private _event;
+}

package/types/SpineAnimationStateData.d.ts

@@ -0,0 +1,10 @@
+import type { SpineSkeletonData } from "./SpineSkeletonData";
+/** Mixing configuration shared by all instances of a resource. */
+export declare class SpineAnimationStateData {
+    readonly skeletonData: SpineSkeletonData;
+    private constructor();
+    get defaultMix(): number;
+    set defaultMix(value: number);
+    /** Set the transition duration between two named animations. */
+    setMix(from: string, to: string, duration: number): void;
+}

package/types/SpineAnimationStateListener.d.ts

@@ -0,0 +1,20 @@
+import type { SpineTrackEntry } from "./SpineTrackEntry";
+/** A snapshot of an authored animation event. It can be retained after the callback returns. */
+export interface SpineEvent {
+    readonly data: {
+        readonly name: string;
+    };
+    readonly time: number;
+    readonly intValue: number;
+    readonly floatValue: number;
+    readonly stringValue: string | null;
+}
+/** Playback callbacks receive Spine public objects, never backend handles. */
+export interface SpineAnimationStateListener {
+    start?(entry: SpineTrackEntry): void;
+    interrupt?(entry: SpineTrackEntry): void;
+    end?(entry: SpineTrackEntry): void;
+    dispose?(entry: SpineTrackEntry): void;
+    complete?(entry: SpineTrackEntry): void;
+    event?(entry: SpineTrackEntry, event: SpineEvent): void;
+}

package/types/SpineBone.d.ts

@@ -0,0 +1,28 @@
+/** A bone's local pose and evaluated world transform, owned by one skeleton instance. */
+export declare class SpineBone {
+    private _native;
+    private constructor();
+    get name(): string;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get rotation(): number;
+    set rotation(value: number);
+    get scaleX(): number;
+    set scaleX(value: number);
+    get scaleY(): number;
+    set scaleY(value: number);
+    get shearX(): number;
+    set shearX(value: number);
+    get shearY(): number;
+    set shearY(value: number);
+    get a(): number;
+    get b(): number;
+    get c(): number;
+    get d(): number;
+    get worldX(): number;
+    get worldY(): number;
+    isActive(): boolean;
+    setToSetupPose(): void;
+}

package/types/SpineConstant.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Vertex stride (float count per vertex) of the spine vertex layout owned by `SpineAnimationRenderer`.
+ *
+ * - `withoutTint`: [x, y, z, r, g, b, a, u, v] = 9 floats
+ * - `withTint`:    [x, y, z, r, g, b, a, u, v, dr, dg, db] = 12 floats
+ *
+ * The renderer supplies the matching stride to backend generators through the geometry contract.
+ */
+export declare const SpineVertexStride: {
+    readonly withoutTint: 9;
+    readonly withTint: 12;
+};

package/types/SpinePhysics.d.ts

@@ -0,0 +1,17 @@
+import { SpinePhysicsConstraint } from "./SpinePhysicsConstraint";
+/** Physics availability for the bound asset. Narrow supported before accessing value. */
+export type SpinePhysicsSupport = {
+    readonly supported: true;
+    readonly value: SpinePhysics;
+} | {
+    readonly supported: false;
+    readonly reason: string;
+};
+/** Physics controls evaluated by the skeleton's backend. */
+export declare class SpinePhysics {
+    private _native;
+    readonly physicsConstraints: readonly SpinePhysicsConstraint[];
+    private constructor();
+    physicsTranslate(x: number, y: number): void;
+    physicsRotate(x: number, y: number, degrees: number): void;
+}

package/types/SpinePhysicsConstraint.d.ts

@@ -0,0 +1,22 @@
+/** An instance's physics constraint. Changes affect only this skeleton. */
+export declare class SpinePhysicsConstraint {
+    private _native;
+    private constructor();
+    get name(): string;
+    get inertia(): number;
+    set inertia(value: number);
+    get strength(): number;
+    set strength(value: number);
+    get damping(): number;
+    set damping(value: number);
+    get massInverse(): number;
+    set massInverse(value: number);
+    get wind(): number;
+    set wind(value: number);
+    get gravity(): number;
+    set gravity(value: number);
+    get mix(): number;
+    set mix(value: number);
+    isActive(): boolean;
+    reset(): void;
+}

package/types/SpineSkeleton.d.ts

@@ -0,0 +1,31 @@
+import { SpineBone } from "./SpineBone";
+import { SpineSlot } from "./SpineSlot";
+import type { SpineSkin } from "./SpineSkin";
+import type { SpineSkeletonData } from "./SpineSkeletonData";
+/** The editable pose of one renderer. Bone and slot wrappers are created once and reused. */
+export declare class SpineSkeleton {
+    private _native;
+    readonly data: SpineSkeletonData;
+    readonly bones: readonly SpineBone[];
+    /** Slots in setup order, independent of the animated draw order. */
+    readonly slots: readonly SpineSlot[];
+    private constructor();
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get scaleX(): number;
+    set scaleX(value: number);
+    get scaleY(): number;
+    set scaleY(value: number);
+    get skin(): SpineSkin | null;
+    findBone(name: string): SpineBone | null;
+    findSlot(name: string): SpineSlot | null;
+    setSkinByName(name: string): void;
+    /** Assign a skin from this resource, or clear the current skin. */
+    setSkin(skin: SpineSkin | null): void;
+    setAttachment(slotName: string, attachmentName: string | null): void;
+    setToSetupPose(): void;
+    setBonesToSetupPose(): void;
+    setSlotsToSetupPose(): void;
+}

package/types/SpineSkeletonData.d.ts

@@ -0,0 +1,18 @@
+import type { SpineAnimation } from "./SpineAnimation";
+import { SpineSkin } from "./SpineSkin";
+/** Shared asset metadata, animations and skins. Instances retain the same data object. */
+export declare class SpineSkeletonData {
+    private _skins;
+    readonly animations: readonly SpineAnimation[];
+    readonly skins: readonly SpineSkin[];
+    private constructor();
+    get name(): string | null;
+    get version(): string | null;
+    get x(): number;
+    get y(): number;
+    get width(): number;
+    get height(): number;
+    get defaultSkin(): SpineSkin | null;
+    findSkin(name: string): SpineSkin | null;
+    findAnimation(name: string): SpineAnimation | null;
+}

package/types/SpineSkin.d.ts

@@ -0,0 +1,7 @@
+/** A shared skin belonging to one Spine resource. Create composite skins with SpineResource.createSkin. */
+export declare class SpineSkin {
+    private constructor();
+    get name(): string;
+    /** Add all attachments and required bones/constraints from another skin of this resource. */
+    addSkin(skin: SpineSkin): void;
+}

package/types/SpineSlot.d.ts

@@ -0,0 +1,13 @@
+import type { SpineBone } from "./SpineBone";
+/** An attachment slot owned by one skeleton instance. */
+export declare class SpineSlot {
+    private _native;
+    private _skeleton;
+    readonly bone: SpineBone;
+    private constructor();
+    get name(): string;
+    /** Select an attachment by its skin entry name, or clear the slot with null. */
+    setAttachment(name: string | null): void;
+    /** Restore the setup color and attachment, using the current skin. */
+    setToSetupPose(): void;
+}

package/types/SpineTrackEntry.d.ts

@@ -0,0 +1,44 @@
+import type { SpineAnimation } from "./SpineAnimation";
+import type { SpineAnimationStateListener } from "./SpineAnimationStateListener";
+/**
+ * One playback entry. Valid through its dispose callbacks.
+ * After disposal, accessing playback properties throws even if the backend reuses its pooled entry.
+ */
+export declare class SpineTrackEntry {
+    private _native;
+    private _state;
+    private _listener;
+    private _animation;
+    private constructor();
+    get disposed(): boolean;
+    get animation(): SpineAnimation | null;
+    get trackIndex(): number;
+    get next(): SpineTrackEntry | null;
+    get mixingFrom(): SpineTrackEntry | null;
+    get mixingTo(): SpineTrackEntry | null;
+    get listener(): SpineAnimationStateListener | null;
+    set listener(value: SpineAnimationStateListener | null);
+    get loop(): boolean;
+    set loop(value: boolean);
+    get delay(): number;
+    set delay(value: number);
+    get trackTime(): number;
+    set trackTime(value: number);
+    get trackEnd(): number;
+    set trackEnd(value: number);
+    get timeScale(): number;
+    set timeScale(value: number);
+    get alpha(): number;
+    set alpha(value: number);
+    get animationStart(): number;
+    set animationStart(value: number);
+    get animationEnd(): number;
+    set animationEnd(value: number);
+    get mixTime(): number;
+    set mixTime(value: number);
+    get mixDuration(): number;
+    set mixDuration(value: number);
+    getAnimationTime(): number;
+    isComplete(): boolean;
+    private _requireNative;
+}

package/types/enums/SpineBlendMode.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Blend mode of a spine slot.
+ *
+ * @remarks
+ * Version-neutral mirror of spine-core's `BlendMode` enum. The values match spine-core across all
+ * supported runtime versions (3.8 / 4.2), so a core package can pass its `BlendMode` straight through.
+ * Owning it here keeps the shared package free of any runtime spine-core dependency.
+ */
+export declare enum SpineBlendMode {
+    Normal = 0,
+    Additive = 1,
+    Multiply = 2,
+    Screen = 3
+}

package/types/index.d.ts

@@ -1,10 +1,16 @@
-import "./SpineLoader";
-export { SpineRenderer } from "./SpineRenderer";
-export { SpineAnimation } from "./SpineAnimation";
-export { AssetManager } from "./spine-core/AssetManager";
-export { Texture } from "./spine-core/Texture";
-export { TextureAtlas } from "./spine-core/TextureAtlas";
-export { AtlasAttachmentLoader } from "./spine-core/AtlasAttachmentLoader";
-export { SkeletonJson } from "./spine-core/SkeletonJson";
-export { SkeletonBinary } from "./spine-core/SkeletonBinary";
+export * from "./loader/index";
+export * from "./renderer/index";
+export { SpineSkeleton } from "./SpineSkeleton";
+export { SpineBone } from "./SpineBone";
+export { SpineSlot } from "./SpineSlot";
+export { SpineSkin } from "./SpineSkin";
+export { SpineSkeletonData } from "./SpineSkeletonData";
+export { SpineAnimationStateData } from "./SpineAnimationStateData";
+export { SpineAnimationState } from "./SpineAnimationState";
+export { SpineTrackEntry } from "./SpineTrackEntry";
+export { SpinePhysics } from "./SpinePhysics";
+export { SpinePhysicsConstraint } from "./SpinePhysicsConstraint";
+export type { SpineAnimation } from "./SpineAnimation";
+export type { SpineAnimationStateListener, SpineEvent } from "./SpineAnimationStateListener";
+export type { SpinePhysicsSupport } from "./SpinePhysics";
 export declare const version = "__buildVersion";

package/types/loader/LoaderUtils.d.ts

@@ -0,0 +1 @@
+export {};

package/types/loader/SpineLoader.d.ts

@@ -0,0 +1,21 @@
+import type { ISpineRuntime } from "../runtime/ISpineRuntime";
+import { AssetPromise, Engine, EngineConfiguration, Loader, LoadItem, ResourceManager } from "@galacean/engine";
+import { SpineResource } from "./SpineResource";
+export declare class SpineLoader extends Loader<SpineResource> {
+    private static _decoder;
+    private _runtimes;
+    static _getUrlExtension(url: string): string | null;
+    private static _groupAssetsByExtension;
+    private static _assignAssetPathsFromUrl;
+    private static _getUrlPath;
+    initialize(engine: Engine, configuration: EngineConfiguration): void;
+    load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<SpineResource>;
+    private _getRuntime;
+    private _loadAndCreateSpineResource;
+}
+declare module "@galacean/engine" {
+    interface EngineConfiguration {
+        /** Initial Spine backend. Import engine-spine before creating the engine. */
+        spine?: ISpineRuntime;
+    }
+}

package/types/loader/SpineResource.d.ts

@@ -0,0 +1,37 @@
+import { SpineSkeletonData } from "../SpineSkeletonData";
+import { SpineAnimationStateData } from "../SpineAnimationStateData";
+import type { SpineSkin } from "../SpineSkin";
+import { Entity, ReferResource } from "@galacean/engine";
+/**
+ * Represents a resource that manages Spine animation data, textures, and entity templates for the Galacean engine.
+ *
+ */
+export declare class SpineResource extends ReferResource {
+    /** The url of spine resource. */
+    readonly url: string;
+    private _texturesInSpineAtlas;
+    private _skeletonData;
+    private _stateData;
+    private _template;
+    private constructor();
+    /**
+     * The skeleton data associated with this Spine resource.
+     */
+    get skeletonData(): SpineSkeletonData;
+    /**
+     * The animation state data associated with this Spine resource.
+     */
+    get stateData(): SpineAnimationStateData;
+    /**
+     * Create an empty skin for composing skins/attachments from this resource.
+     * The returned skin can be assigned to one or more instances of this resource.
+     */
+    createSkin(name: string): SpineSkin;
+    /** Creates an independent pose and playback state using this resource's shared data. */
+    instantiate(): Entity;
+    protected _onDestroy(): void;
+    private _createTemplate;
+    private _associationTextureInSkeletonData;
+    private _disassociateTextures;
+    private _extractFileName;
+}

package/types/loader/SpineVersion.d.ts

@@ -0,0 +1,2 @@
+/** Read only the export header, before selecting or invoking a version-specific parser. */
+export declare function readSpineVersion(data: string | ArrayBuffer): string;

package/types/loader/index.d.ts

@@ -0,0 +1,2 @@
+import "./SpineLoader";
+export { SpineResource } from "./SpineResource";