@galacean/engine-spine 0.0.0-experimental-6d3110b4d9-20240531 → 0.0.0-experimental-c21bcd627b-20240711

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0-experimental-6d3110b4d9-20240531",
+  "version": "0.0.0-experimental-c21bcd627b-20240711",
   "description": "galacean spine runtime",
   "name": "@galacean/engine-spine",
   "main": "dist/main.js",
@@ -29,8 +29,10 @@
     "@rollup/plugin-terser": "^0.4.3",
     "@swc/core": "^1.3.32",
     "@swc/helpers": "^0.5",
+    "@vitejs/plugin-basic-ssl": "^1.1.0",
     "cross-env": "^5.2.0",
     "dat.gui": "^0.7.9",
+    "floss": "^5.0.1",
     "react": "^16.14.0",
     "react-dom": "^16.14.0",
     "rollup": "^2.32.0",
@@ -53,8 +55,9 @@
   ],
   "scripts": {
     "example": "vite",
-    "test": "jest",
-    "test-cov": "jest --coverage",
+    "test": "cross-env TS_NODE_PROJECT=tsconfig.tests.json floss --path tests -r ts-node/register",
+    "test-debug": "cross-env TS_NODE_PROJECT=tsconfig.tests.json floss --path tests -r ts-node/register --debug",
+    "test-cov": "cross-env TS_NODE_PROJECT=tsconfig.tests.json IS_COV=1 nyc --reporter=lcov floss --path tests -r ts-node/register",
     "dev": "rollup -cw",
     "build": "npm run b:types && cross-env BUILD_TYPE=ALL rollup -c",
     "build:watch": "npm run b:types && cross-env BUILD_TYPE=ALL rollup -c --watch",

package/types/SpineAnimation.d.ts

@@ -1,37 +1,79 @@
-import { Skeleton, SkeletonData, AnimationState } from "@esotericsoftware/spine-core";
-import { SpineGenerator } from "./core/SpineGenerator";
-import { SpineRenderSetting } from "./types";
-import { Renderer, Entity, Material, Engine, BoundingBox, Primitive } from "@galacean/engine";
-import { SubPrimitive } from "./core/SpinePrimitive";
+import { Skeleton, SkeletonData, AnimationState, AnimationStateData } from "@esotericsoftware/spine-core";
+import { Buffer, Renderer, Entity, Material, Engine, BoundingBox, Primitive, SubPrimitive } from "@galacean/engine";
+import { SkeletonDataResource } from "./loader/SkeletonDataResource";
+declare module '@esotericsoftware/spine-core' {
+    interface SkeletonData {
+        refCount: number;
+    }
+}
 interface InitialState {
     animationName: string;
     skinName: string;
     loop: boolean;
     scale: number;
 }
+export type SpineRenderSetting = {
+    useClipping: boolean;
+    zSpacing: number;
+};
 export declare class SpineAnimation extends Renderer {
     private static _defaultMaterial;
-    private static _uvMacro;
-    private static _enableVertexColorMacro;
-    private static _tempOffset;
-    private static _tempSize;
-    private static _tempArray;
+    private static _spineGenerator;
+    private static positionVertexElement;
+    private static colorVertexElement;
+    private static uvVertexElement;
+    static materialCache: Map<string, Material>;
+    static animationDataCache: Map<SkeletonData, AnimationStateData>;
     static getDefaultMaterial(engine: Engine): Material;
+    /** Render setting for spine rendering. */
     setting: SpineRenderSetting;
+    /** Initial spine animation and skin state. */
     initialState: InitialState;
+    /** @internal */
     _primitive: Primitive;
+    /** @internal */
     _subPrimitives: SubPrimitive[];
-    protected _skeleton: Skeleton;
-    protected _state: AnimationState;
-    protected _spineGenerator: SpineGenerator;
-    set skeletonData(value: SkeletonData);
+    /** @internal */
+    _indexBuffer: Buffer;
+    /** @internal */
+    _vertexBuffer: Buffer;
+    /** @internal */
+    _vertices: Float32Array;
+    /** @internal */
+    _indices: Uint16Array;
+    /** @internal */
+    _needResizeBuffer: boolean;
+    /** @internal */
+    _vertexCount: number;
+    /** @internal */
+    _resource: SkeletonDataResource;
+    private _skeleton;
+    private _state;
+    /**
+     * Setting `skeletonData` initializes a new Spine animation with the provided data.
+     * This property allows you to switch between different animations at runtime.
+     */
+    set resource(value: SkeletonDataResource);
+    /**
+     * Provides access to `AnimationState` which controls animation playback on a skeleton.
+     * You can use its API to manage, blend, and transition between multiple simultaneous animations effectively.
+     */
     get state(): AnimationState;
+    /**
+     * Provides access to `Skeleton`, which defines the structure of a Spine model.
+     * Through its API, users can manipulate bone positions, rotations, scaling
+     * and change spine attachment to customize character appearances dynamically during runtime.
+     */
     get skeleton(): Skeleton;
+    /**
+     * @internal
+     */
+    get engine(): Engine;
     constructor(entity: Entity);
     /**
      * @internal
      */
-    _onAwake(): void;
+    _onEnable(): void;
     /**
      * Separate slot by slot name. This will add a new sub primitive, and new materials.
      */
@@ -47,18 +89,71 @@ export declare class SpineAnimation extends Renderer {
     /**
      * @internal
      */
-    protected _render(context: any): void;
+    _render(context: any): void;
+    /**
+     * @internal
+     */
+    _updateBounds(worldBounds: BoundingBox): void;
+    /**
+   * @internal
+   */
+    _calculateGeneratorBounds(worldBounds: BoundingBox): void;
+    /**
+     * @internal
+     */
+    _cloneTo(target: SpineAnimation): void;
     /**
      * @internal
      */
-    protected _updateBounds(worldBounds: BoundingBox): void;
+    _onDestroy(): void;
     /**
      * @internal
      */
-    _cloneTo(target: SpineAnimation, srcRoot: Entity, targetRoot: Entity): void;
+    _createBuffer(vertexCount: number): void;
     /**
      * @internal
      */
-    protected _onDestroy(): void;
+    _addSubPrimitive(subPrimitive: SubPrimitive): void;
+    /**
+     * @internal
+     */
+    _clearSubPrimitives(): void;
+    /**
+     * @internal
+     */
+    _isContainDirtyFlag(type: number): boolean;
+    /**
+     * @internal
+     */
+    _setDirtyFlagFalse(type: number): void;
+    /**
+     * @internal
+     */
+    _onAnimationStart(): void;
+    /**
+     * @internal
+     */
+    _onTransformChanged(): void;
+    private onAnimationStart;
+    private onAnimationComplete;
+    private _clearMaterialCache;
+}
+/**
+ * @internal
+ */
+export declare enum SpineAnimationUpdateFlags {
+    /** On World Transform Changed */
+    TransformVolume = 1,
+    /** On Animation start play */
+    AnimationVolume = 2,
+    /** On skeleton data asset changed */
+    AssetVolume = 4
+}
+/**
+ * @internal
+ */
+export declare enum RendererUpdateFlags {
+    /** Include world position and world bounds. */
+    WorldVolume = 1
 }
 export {};

package/types/SpineGenerator.d.ts

@@ -0,0 +1,40 @@
+import { Texture2D, SubPrimitive, Vector3 } from "@galacean/engine";
+import { Skeleton, Color, BlendMode, SkeletonData } from "@esotericsoftware/spine-core";
+import { SpineAnimation } from "./SpineAnimation";
+import { AdaptiveTexture } from "./loader/LoaderUtils";
+import { ReturnablePool } from "./util/ReturnablePool";
+import { ClearablePool } from "./util/ClearablePool";
+declare class SubRenderItem {
+    subPrimitive: SubPrimitive;
+    blendMode: BlendMode;
+    texture: any;
+    slotName?: string;
+}
+export declare class SpineGenerator {
+    static QUAD_TRIANGLES: number[];
+    static VERTEX_SIZE: number;
+    static VERTEX_STRIDE: number;
+    static tempDark: Color;
+    static tempColor: Color;
+    static tempVerts: any[];
+    static tempBlendMode: BlendMode | null;
+    static tempTexture: AdaptiveTexture | null;
+    static subPrimitivePool: ReturnablePool<SubPrimitive>;
+    static subRenderItemPool: ClearablePool<SubRenderItem>;
+    bounds: {
+        min: Vector3;
+        max: Vector3;
+    };
+    private _clipper;
+    private _subRenderItems;
+    private _separateSlots;
+    private _separateSlotTextureMap;
+    getMaxVertexCount(skeletonData: SkeletonData): number;
+    buildPrimitive(skeleton: Skeleton, renderer: SpineAnimation): void;
+    addSeparateSlot(slotName: string): void;
+    addSeparateSlotTexture(slotName: string, texture: Texture2D): void;
+    private createMaterialForTexture;
+    private expandByPoint;
+    private getSkinVertexCount;
+}
+export {};

package/types/core/SpineGenerator.d.ts

@@ -1,6 +1,5 @@
-import { Engine, Texture2D } from "@galacean/engine";
+import { Engine, Texture2D, SubPrimitive } from "@galacean/engine";
 import { Skeleton, SkeletonData, Color, BlendMode } from "@esotericsoftware/spine-core";
-import { SubPrimitive } from "./SpinePrimitive";
 import { SpineRenderSetting } from "../types";
 import { AdaptiveTexture } from "../loader/LoaderUtils";
 import { SpineAnimation } from "../SpineAnimation";

package/types/core/SpinePrimitive.d.ts

@@ -1,12 +1,4 @@
-import { Engine, Buffer, MeshTopology } from '@galacean/engine';
-export declare class SubPrimitive {
-    /** Start drawing offset. */
-    start: number;
-    /** Drawing count. */
-    count: number;
-    /** Drawing topology. */
-    topology?: MeshTopology;
-}
+import { Engine, Buffer, SubPrimitive } from '@galacean/engine';
 export declare class SpinePrimitive {
     private _primitive;
     private _subPrimitive;

package/types/index.d.ts

@@ -1,7 +1,7 @@
 import "./loader/SpineLoader";
-import "./loader/EditorSkeletonDataLoader";
 import "./loader/EditorSpineAtlasLoader";
 export { SpineAnimation } from "./SpineAnimation";
+export { SkeletonDataResource } from "./loader/SkeletonDataResource";
+export { createTextureAtlas } from "./loader/LoaderUtils";
 export * from "@esotericsoftware/spine-core";
-export { generateTextureAtlas } from "./loader/LoaderUtils";
 export declare const version = "__buildVersion";

package/types/loader/EditorSkeletonDataLoader.d.ts

@@ -1,6 +1,6 @@
 import { AssetPromise, Loader, LoadItem, ResourceManager } from "@galacean/engine";
-import { SkeletonData } from "@esotericsoftware/spine-core";
-declare class EditorSkeletonDataLoader extends Loader<SkeletonData> {
-    load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<SkeletonData>;
+import { SkeletonDataResource } from "./SkeletonDataResource";
+declare class EditorSkeletonDataLoader extends Loader<SkeletonDataResource> {
+    load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<SkeletonDataResource>;
 }
 export { EditorSkeletonDataLoader };

package/types/loader/LoaderUtils.d.ts

@@ -1,8 +1,9 @@
 import { Engine, Texture2D } from "@galacean/engine";
 import { TextureAtlas, SkeletonData, Texture, TextureFilter, TextureWrap } from "@esotericsoftware/spine-core";
-import { SpineAssetBundle } from "./SpineLoader";
-export declare function loadAndCreateSpineSkeletonData(bundle: SpineAssetBundle, engine: Engine): Promise<SkeletonData>;
-export declare function generateTextureAtlas(atlasText: string, textureMap: Record<string, Texture2D>): TextureAtlas;
+export declare function createSkeletonData(textureAtlas: TextureAtlas, skeletonTextData: string | ArrayBuffer, skeletonFileType: 'json' | 'skel'): SkeletonData;
+export declare function loadTexturesByPath(imagePaths: string[], imageExtensions: string[], engine: Engine): Promise<Texture2D[]>;
+export declare function loadTextureAtlas(atlasPath: string, engine: Engine): Promise<TextureAtlas>;
+export declare function createTextureAtlas(atlasText: string, textures: Texture2D[]): TextureAtlas;
 export declare function getBaseUrl(url: string): string;
 export declare class AdaptiveTexture extends Texture {
     texture: Texture2D;

package/types/loader/SkeletonDataResource.d.ts

@@ -0,0 +1,12 @@
+import { SkeletonData } from "@esotericsoftware/spine-core";
+import { Engine, ReferResource, Texture2D } from "@galacean/engine";
+export declare class SkeletonDataResource extends ReferResource {
+    readonly textures: Texture2D[];
+    private _skeletonData;
+    get skeletonData(): SkeletonData;
+    constructor(engine: Engine, skeletonData: SkeletonData);
+    protected _onDestroy(): void;
+    private _disassociationSuperResource;
+    private _associationTextureInSkeletonData;
+    private _clearAttachmentTextures;
+}

package/types/loader/SpineLoader.d.ts

@@ -1,8 +1,9 @@
 import { AssetPromise, Loader, LoadItem, ResourceManager } from "@galacean/engine";
-import { SkeletonData } from "@esotericsoftware/spine-core";
+import { SkeletonDataResource } from "./SkeletonDataResource";
 export type SpineAssetBundle = {
     skeletonPath: string;
     skeletonExtension: string;
+    skeletonTextData?: string | ArrayBuffer;
     atlasPath: string;
     imagePaths: string[];
     imageExtensions: string[];
@@ -13,9 +14,15 @@ type SpineLoaderParams = {
 type SpineLoadItem = LoadItem & {
     params?: SpineLoaderParams;
 };
-declare class SpineLoader extends Loader<SkeletonData> {
+export declare class SpineLoader extends Loader<SkeletonDataResource> {
     static imageExtensions: string[];
     static skeletonExtensions: string[];
-    load(item: SpineLoadItem, resourceManager: ResourceManager): AssetPromise<SkeletonData>;
+    static parseAndAssignSpineAsset(url: string, fileExtension: string | null, bundle: SpineAssetBundle): void;
+    static deriveAndAssignSpineAsset(url: string, fileExtension: string | null, bundle: SpineAssetBundle): void;
+    static verifyFileExtensions(fileExtensions: string | string[], expectArray: boolean): string | string[] | null;
+    load(item: SpineLoadItem, resourceManager: ResourceManager): AssetPromise<SkeletonDataResource>;
+    private _handleEditorAsset;
+    private _handleOriginAsset;
+    private determineSkeletonDataType;
 }
-export { SpineLoader };
+export {};

package/types/util/BlendMode.d.ts

@@ -0,0 +1,4 @@
+import { BlendMode } from "@esotericsoftware/spine-core";
+import { Material } from "@galacean/engine";
+export declare function setBlendMode(material: Material, blendMode: BlendMode): void;
+export declare function getBlendMode(material: Material): BlendMode;

package/types/util/BufferReader.d.ts

@@ -0,0 +1,10 @@
+export declare class BufferReader {
+    data: Uint8Array;
+    private _dataView;
+    private _position;
+    constructor(data: Uint8Array, byteOffset?: number, byteLength?: number);
+    nextUint16(): number;
+    nextStr(): string;
+    nextImageData(): Uint8Array;
+    private decodeText;
+}

package/types/util/Cache.d.ts

@@ -0,0 +1,19 @@
+import { SkeletonData, AnimationStateData } from "@esotericsoftware/spine-core";
+import { Material } from "@galacean/engine";
+declare class Cache<K, V> {
+    protected _cache: Map<K, V>;
+    get(key: K): V;
+    set(key: K, value: V): void;
+    clear(keys?: K[]): void;
+}
+export declare class AnimationStateDataCache extends Cache<SkeletonData, AnimationStateData> {
+    private static _instance;
+    static get instance(): AnimationStateDataCache;
+    getAnimationStateData(skeletonData: SkeletonData): AnimationStateData;
+}
+export declare class MaterialCache extends Cache<string, Material> {
+    private static _instance;
+    static get instance(): MaterialCache;
+    getMaterial(key: string): Material;
+}
+export {};

package/types/util/ClearablePool.d.ts

@@ -0,0 +1,8 @@
+export declare class ClearablePool<T> {
+    private _type;
+    private _elements;
+    private _usedElementCount;
+    constructor(type: new () => T);
+    get(): T;
+    clear(): void;
+}

package/types/util/ReturnablePool.d.ts

@@ -0,0 +1,8 @@
+export declare class ReturnablePool<T> {
+    private _type;
+    private _elements;
+    private _lastElementIndex;
+    constructor(type: new () => T, initializeCount?: number);
+    get(): T;
+    return(element: T): void;
+}