@galacean/engine-spine 1.1.0-beta.9 → 1.1.0-test.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.0-beta.9",
+  "version": "1.1.0-test.1",
   "description": "galacean spine runtime",
   "name": "@galacean/engine-spine",
   "main": "dist/main.js",

package/types/SpineAnimation.d.ts

@@ -16,8 +16,8 @@ export declare class SpineAnimation extends Script {
     private _tempArray;
     protected _meshGenerator: MeshGenerator;
     setting: SpineRenderSetting;
-    autoUpdate: boolean;
     autoUpdateBounds: boolean;
+    noPause: boolean;
     get skeletonData(): SkeletonData;
     get skeleton(): Skeleton;
     get state(): AnimationState;
@@ -34,7 +34,6 @@ export declare class SpineAnimation extends Script {
      */
     hackSeparateSlotTexture(slotName: string, texture: Texture2D): void;
     onUpdate(delta: number): void;
-    updateState(deltaTime: number): void;
     updateGeometry(): void;
     updateBounds(): void;
     /**

package/types/SpineLoader.d.ts

@@ -1,30 +1,31 @@
-import { AssetPromise, Loader, LoadItem, ResourceManager, TextureWrapMode, Texture2D, Engine, Entity } from "@galacean/engine";
+import { AssetPromise, Loader, LoadItem, ResourceManager, TextureWrapMode, Texture2D, Entity, AssetType } from "@galacean/engine";
 import { AssetManager } from "./spine-core/AssetManager";
 import { Texture } from "./spine-core/Texture";
 type SpineResouce = {
     skeletonFile: string;
     atlasFile: string;
     textureFile?: string;
+    textureType?: AssetType;
 };
 type SpineOpt = {
     scale: number;
 };
 type SpineLoadItem = LoadItem & SpineOpt;
 declare class SpineLoader extends Loader<Entity> {
+    constructor();
     load(item: SpineLoadItem, resourceManager: ResourceManager): AssetPromise<Entity>;
     handleResource(resourceManager: ResourceManager, item: SpineLoadItem, resource: SpineResouce, resolve: any, reject: any): void;
     textureAssetPicker(assetManager: AssetManager, textureFile: string): any;
-    createAdaptiveTexture(img: any, engine: any): AdaptiveTexture;
+    createAdaptiveTexture(texture: Texture2D): AdaptiveTexture;
     isBinFile(url: string): boolean;
     checkUrl(url: string): boolean;
     getResouceFromUrl(url: any): SpineResouce;
     checkUrls(urls: string[]): boolean;
-    getResouceFromUrls(urls: string[]): SpineResouce;
+    getResouceFromUrls(urls: string[], type?: AssetType): SpineResouce;
     getExtFromUrl(url: string): string;
 }
 export declare class AdaptiveTexture extends Texture {
-    texture: Texture2D;
-    constructor(data: HTMLImageElement, engine: Engine);
+    constructor(texture: Texture2D);
     setFilters(minFilter: any, magFilter: any): void;
     setWraps(uWrap: TextureWrapMode, vWrap: TextureWrapMode): void;
     dispose(): void;

package/types/SpineRenderer.d.ts

@@ -1,26 +1,38 @@
 import { Script, Entity } from "@galacean/engine";
 import { SpineAnimation } from "./SpineAnimation";
 export declare class SpineRenderer extends Script {
+    private _priority;
     private _resource;
     private _animationName;
     private _loop;
+    private _paused;
     private _autoPlay;
+    private _skinName;
     private _scale;
     private _spineAnimation;
     /** @internal */
     _animationNames: Array<string>;
+    /** @internal */
+    _skinNames: Array<string>;
+    get priority(): number;
+    set priority(value: number);
     get resource(): Entity | null;
     set resource(value: Entity | null);
     get animationName(): string;
     set animationName(name: string);
     get loop(): boolean;
     set loop(value: boolean);
+    get paused(): boolean;
+    set paused(value: boolean);
     get autoPlay(): boolean;
     set autoPlay(value: boolean);
+    get skinName(): string;
+    set skinName(name: string);
     get scale(): number;
     set scale(value: number);
     get spineAnimation(): SpineAnimation;
     onDestroy(): void;
     play(name?: string, loop?: boolean): void;
+    _cloneTo(target: SpineRenderer): void;
     private _removeResource;
 }

package/types/core/MeshGenerator.d.ts

@@ -1,17 +1,20 @@
-import { Engine, Entity, SubMesh } from '@galacean/engine';
-import { Skeleton } from '../spine-core/Skeleton';
-import { SkeletonData } from '../spine-core/SkeletonData';
-import { Color } from '../spine-core/Utils';
-import { SpineRenderSetting } from '../types';
+import { Engine, Entity, SubMesh, Texture2D } from "@galacean/engine";
+import { Skeleton } from "../spine-core/Skeleton";
+import { SkeletonData } from "../spine-core/SkeletonData";
+import { Color } from "../spine-core/Utils";
+import { SpineRenderSetting } from "../types";
+import { BlendMode } from "../spine-core/BlendMode";
 type SubMeshItem = {
     subMesh: SubMesh;
-    name: string;
+    blendMode: BlendMode;
+    texture: any;
 };
 export declare class MeshGenerator {
     static QUAD_TRIANGLES: number[];
     static VERTEX_SIZE: number;
     static VERTEX_STRIDE: number;
     static tempColor: Color;
+    static tempBlendMode: BlendMode | null;
     private _setting;
     private _engine;
     private _entity;
@@ -25,12 +28,15 @@ export declare class MeshGenerator {
     private _meshRenderer;
     private _subMeshItems;
     readonly separateSlots: string[];
+    readonly separateSlotTextures: Map<string, Texture2D>;
     get mesh(): import("@galacean/engine").BufferMesh;
     get subMeshItems(): SubMeshItem[];
     constructor(engine: Engine, entity: Entity);
     initialize(skeletonData: SkeletonData, setting?: SpineRenderSetting): void;
     buildMesh(skeleton: Skeleton): void;
     addSeparateSlot(slotName: string): void;
+    addSeparateSlotTexture(slotName: string, texture: Texture2D): void;
     private _prepareBufferData;
+    private setBlendMode;
 }
 export {};

package/types/spine-core/AssetManager.d.ts

@@ -1,16 +1,19 @@
+import { AssetType, Engine, Texture2D } from "@galacean/engine";
 import { Disposable, Map } from "./Utils";
 import { TextureAtlas } from "./TextureAtlas";
 import { AdaptiveTexture } from "../SpineLoader";
 export declare class AssetManager implements Disposable {
+    private _engine;
     protected pathPrefix: string;
-    protected textureLoader: (image: HTMLImageElement) => AdaptiveTexture;
+    protected textureLoader: (texture: Texture2D) => AdaptiveTexture;
     protected assets: Map<any>;
     protected errors: Map<string>;
     protected toLoad: number;
     protected loaded: number;
     protected rawDataUris: Map<string>;
     onLoadComplete: any;
-    constructor(pathPrefix?: string, textureLoader?: (image: HTMLImageElement) => AdaptiveTexture);
+    get engine(): Engine;
+    constructor(engine: Engine, pathPrefix?: string, textureLoader?: (texture: Texture2D) => AdaptiveTexture);
     private downloadText;
     protected downloadBinary(url: string, success: (data: Uint8Array) => void, error: (status: number, responseText: string) => void): void;
     setRawDataURI(path: string, data: string): void;
@@ -18,6 +21,7 @@ export declare class AssetManager implements Disposable {
     loadText(path: string, success?: (path: string, text: string) => void, error?: (error: string) => void): void;
     loadImage(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (error: string) => void): void;
     loadTexture(path: string, success?: (path: string, texture: AdaptiveTexture) => void, error?: (error: string) => void): void;
+    loadEngineTexture(path: string, type: AssetType, success?: (path: string, texture: AdaptiveTexture) => void, error?: (error: string) => void): void;
     loadTextureAtlas(path: string, success?: (path: string, atlas: TextureAtlas) => void, error?: (error: string) => void): void;
     get(path: string): any;
     remove(path: string): void;

package/types/spine-core/Texture.d.ts

@@ -1,7 +1,10 @@
+import { Texture2D } from "@galacean/engine";
 export declare abstract class Texture {
-    protected _image: HTMLImageElement | ImageBitmap;
-    constructor(image: HTMLImageElement | ImageBitmap);
-    getImage(): HTMLImageElement | ImageBitmap;
+    protected _texture: Texture2D;
+    constructor(texture: Texture2D);
+    get width(): number;
+    get height(): number;
+    get texture(): Texture2D;
     abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
     abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
     abstract dispose(): void;

package/types/AntGSpineLoader.d.ts

@@ -1,22 +0,0 @@
-import { AssetPromise, Loader, LoadItem, ResourceManager, TextureWrapMode, Texture2D, Engine, Entity } from '@galacean/engine';
-import { AssetManager } from './spine-core/AssetManager';
-import { Texture } from './spine-core/Texture';
-type SpineOpt = {
-    scale: number;
-};
-type SpineLoadItem = LoadItem & SpineOpt;
-declare class SpineLoader extends Loader<Entity> {
-    load(item: SpineLoadItem, resourceManager: ResourceManager): AssetPromise<Entity>;
-    textureAssetPicker(assetManager: AssetManager, textureFile: string): any;
-    createAdaptiveTexture(img: any, engine: any): AdaptiveTexture;
-    checkUrl(url: string): boolean;
-    getExtFromUrl(url: string): string;
-}
-export declare class AdaptiveTexture extends Texture {
-    texture: Texture2D;
-    constructor(data: HTMLImageElement, engine: Engine);
-    setFilters(minFilter: any, magFilter: any): void;
-    setWraps(uWrap: TextureWrapMode, vWrap: TextureWrapMode): void;
-    dispose(): void;
-}
-export { SpineLoader };

package/types/SpineComponent.d.ts

@@ -1,17 +0,0 @@
-import { Script, Entity } from '@galacean/engine';
-export declare class SpineComponent extends Script {
-    private _autoPlay;
-    private _scale;
-    private _animationName;
-    private _resource;
-    onStart(): void;
-    get animationName(): string;
-    set animationName(name: string);
-    get resource(): Entity;
-    set resource(r: Entity);
-    get autoPlay(): boolean;
-    set autoPlay(value: boolean);
-    get scale(): number;
-    set scale(value: number);
-    onDestroy(): void;
-}