Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

17.8 KB
Raw Blame

API surface — esengine/spine

Symbols: 0 public · 1 beta · 50 experimental · 0 deprecated

ConstraintList — interface @experimental

ik: string[]
path: string[]
transform: string[]

NO_CERTIFICATES — const @experimental

SpineCertificateSource

PathMixData — interface @experimental

mixRotate: number
mixX: number
mixY: number
position: number
spacing: number

RuntimeAssetSource — interface @experimental

backend: Backend
compressedTexture: ((path: string) => Promise<Uint8Array | "pending" | null>) | undefined
decodePixels: (path: string, flip: boolean, maxEdge?: number) => Promise<{ width: number; height: number; pixels: Uint8Array; }>
listAssetPaths: (() => string[]) | undefined
resolveAddress: ((ref: string) => string | null) | undefined
resolveRef: ((ref: string) => string) | undefined
spineCulling: ((skeleton: string, atlas: string) => { x: number; y: number; width: number; height: number; } | undefined) | undefined
textureImportSettings: ((ref: string) => ParsedTextureImportSettings | undefined) | undefined

SkeletalBone — interface @experimental

degrees: number
length: number
name: string
parent: number
x: number
y: number

SkeletalBoneTree — interface @experimental

bones: SkeletalBone[]
flipX: boolean
flipY: boolean
scale: number

Spine — const @beta

ResourceDef<SpineManager>

SpineAABB — interface @experimental

maxX: number
maxY: number
minX: number
minY: number

SpineAssetDiagnostic — interface @experimental

blockedBy: readonly SpineDeferralBlocker[]
entities: number
envelope: "certified" | "observed" | "unknown"
era: string
mayDefer: boolean
pair: SpinePair
version: SpineVersion

SpineBoundsSource — interface @experimental

animationDuration: (skeletonHandle: number, animation: string) => number
createInstance: (skeletonHandle: number) => number
destroyInstance: (instanceId: number) => void
getAnimations: (instanceId: number) => string[]
getBounds: (instanceId: number) => { x: number; y: number; width: number; height: number; }
getSkins: (instanceId: number) => string[]
play: (instanceId: number, animation: string, loop?: boolean, track?: number) => boolean
setSkin: (instanceId: number, skin: string) => void
skeletonBounds: (skeletonHandle: number) => SpineAABB | null
update: (instanceId: number, dt: number) => void

SpineCertificateSource — interface @experimental

envelopeFor: (skeleton: string, atlas: string) => SpineCullingEnvelope

SpineClipBudget — interface @experimental

bypassedTriangles: number
candidateTriangles: number
chargedTriangles: number
edgeWork: number
effectiveEdges: number
inputVertices: number
outputTriangles: number
outputVertices: number
pieces: number
rawVertices: number
rejectedTriangles: number
triangleAmplification: number
vertexAmplification: number

SpineCullingEnvelope — type @experimental

| { kind: 'certified'; bounds: SpineAABB; source: 'explicit' }
    | {
        kind: 'observed'; bounds: SpineAABB; source: 'animation-scan';
        sampleStep: number; era: string; coverage: SpineScanCoverage;
    }
    | { kind: 'unknown' }

SpineCullingProvider — interface @experimental

spineCulling: ((skeleton: string, atlas: string) => { x: number; y: number; width: number; height: number; } | undefined) | undefined

SpineDeferralBlocker — type @experimental

'no-certificate' | 'stateful-constraints'

SpineDiagnosticRuntime — interface @experimental

entityCount: number
metrics: () => SpineFrameMetrics | null
residencies: () => SpineResidencyFacts[]
version: SpineVersion
windows: () => { pose: SpineTimeWindow; readback: SpineTimeWindow; total: SpineTimeWindow; }
worldPoseDebt: () => number

SpineEvent — interface @experimental

animationName: string
entity: number
eventName: string | undefined
floatValue: number | undefined
intValue: number | undefined
stringValue: string | undefined
track: number
type: SpineEventType

SpineEventType — type @experimental

'start' | 'interrupt' | 'end' | 'complete' | 'event'

SpineEvents — const @experimental

ResourceDef<SpineEventsData>

SpineEventsData — interface @experimental

events: readonly SpineEvent[]

SpineFinding — interface @experimental

assets: readonly string[]
code: SpineFindingCode
entities: number

SpineFindingCode — type @experimental

| 'not-observing'
    /** Assets a culling contract would unlock. The one actionable finding. */
    | 'no-certificate'
    /** Assets no contract can unlock: their world pose carries state. */
    | 'stateful-constraints'
    /** Deferral is permitted and bought nothing this frame — everything was wanted. */
    | 'nothing-deferred'
    /** Deferral is permitted and is paying. */
    | 'deferral-working'

SpineManager — class @experimental

boneTree: (entity: Entity) => SkeletalBoneTree | null
boundEntities: () => Iterable<Entity>
clipBudget: (entity: Entity) => SpineClipBudget | null
collectAllEvents: (isActive?: (entity: Entity) => boolean) => { entity: Entity; raw: RawSpineEvent; }[]
diagnostics: () => SpineSceneDiagnostics
dispose: () => void
enableEvents: (entity: Entity) => void
getAnimations: (entity: Entity) => string[]
getBounds: (entity: Entity) => { x: number; y: number; width: number; height: number; } | null
getEntityVersion: (entity: Entity) => SpineVersion | undefined
getPathConstraintMix: (entity: Entity, name: string) => PathMixData | null
getSkins: (entity: Entity) => string[]
getTransformConstraintMix: (entity: Entity, name: string) => TransformMixData | null
hasInstance: (entity: Entity) => boolean
hasRuntime: (version: SpineVersion) => boolean
listConstraints: (entity: Entity) => ConstraintList | null
loadEntity: (entity: Entity, era: SpineEraBinding, _registry: CppRegistry) => Promise<SpineVersion | null>
observe: (on: boolean) => void
observedBounds: (entity: Entity, sampleStep?: number) => SpineCullingEnvelope | null
observing: boolean
openPreview: (era: SpineEraBinding) => Promise<SpinePreviewInstance | null>
removeEntity: (entity: Entity) => void
setAnimation: (entity: Entity, animation: string, loop: boolean) => void
setAttachment: (entity: Entity, slotName: string, attachmentName: string) => boolean
setDefaultMix: (entity: Entity, duration: number) => void
setEnabled: (entity: Entity, enabled: boolean) => void
setEntityProps: (entity: Entity, props: { skeletonScale?: number; flipX?: boolean; flipY?: boolean; layer?: number; timeScale?: number; playing?: boolean; color?: { r: number; g: number; b: number; a: number; }; }) => void
setIKTarget: (entity: Entity, constraintName: string, targetX: number, targetY: number, mix: number) => boolean
setMixDuration: (entity: Entity, fromAnim: string, toAnim: string, duration: number) => void
setPathConstraintMix: (entity: Entity, name: string, mix: PathMixData) => boolean
setSkin: (entity: Entity, skin: string) => void
setSlotColor: (entity: Entity, slotName: string, r: number, g: number, b: number, a: number) => boolean
setTrackAlpha: (entity: Entity, track: number, alpha: number) => void
setTransformConstraintMix: (entity: Entity, name: string, mix: TransformMixData) => boolean
submitMeshes: (registry: CppRegistry, materialOf?: SkeletalMaterialOf, isActive?: (entity: Entity) => boolean) => void
updateAnimations: (dt: number, isActive?: (entity: Entity) => boolean) => void
static detectVersion: (data: Uint8Array) => SpineVersion | null
static detectVersionJson: (json: string) => SpineVersion | null
static new (coreModule: NonNullable<EngineApi>, moduleFactories: Map<SpineVersion, SpineModuleFactory>): SpineManager
static prototype: SpineManager

SpineModuleController — class @experimental

addAnimation: (instanceId: number, animation: string, loop?: boolean, delay?: number, track?: number) => boolean
advanceAndApply: (instanceId: number, dt: number) => void
animationDuration: (skeletonHandle: number, animation: string) => number
clipBudget: (instanceId: number) => SpineClipBudget | null
collectEvents: (instanceId: number) => RawSpineEvent[]
createInstance: (skeletonHandle: number) => number
destroyInstance: (instanceId: number) => void
enableEvents: (instanceId: number) => void
forEachMeshBatch: (instanceId: number, cb: MeshBatchVisitor, probe?: SkeletalProbe) => void
getAnimations: (instanceId: number) => string[]
getAtlasPageCount: (handle: number) => number
getAtlasPageTextureName: (handle: number, pageIndex: number) => string
getBonePosition: (instanceId: number, boneName: string) => Vec2 | null
getBoneRotation: (instanceId: number, boneName: string) => number
getBoneTree: (instanceId: number) => SkeletalBone[] | null
getBounds: (instanceId: number) => { x: number; y: number; width: number; height: number; }
getLastError: () => string
getPathConstraintMix: (instanceId: number, name: string) => PathMixData | null
getSkins: (instanceId: number) => string[]
getTransformConstraintMix: (instanceId: number, name: string) => TransformMixData | null
listConstraints: (instanceId: number) => ConstraintList
loadSkeleton: (skelData: Uint8Array | string, atlasText: string, isBinary: boolean) => number
materializeWorldPose: (instanceId: number, dt: number) => void
play: (instanceId: number, animation: string, loop?: boolean, track?: number) => boolean
raw: SpineWasmModule
requiresContinuousWorldPose: (skeletonHandle: number) => boolean
setAtlasPageTexture: (handle: number, pageIndex: number, textureId: number, width: number, height: number) => void
setAttachment: (instanceId: number, slotName: string, attachmentName: string) => boolean
setDefaultMix: (skeletonHandle: number, duration: number) => void
setIKTarget: (instanceId: number, constraintName: string, targetX: number, targetY: number, mix: number) => boolean
setMixDuration: (skeletonHandle: number, fromAnim: string, toAnim: string, duration: number) => void
setPathConstraintMix: (instanceId: number, name: string, mix: PathMixData) => boolean
setSkeletonColor: (instanceId: number, r: number, g: number, b: number, a: number) => boolean
setSkin: (instanceId: number, skinName: string) => void
setSlotColor: (instanceId: number, slotName: string, r: number, g: number, b: number, a: number) => boolean
setToSetupPose: (instanceId: number) => void
setTrackAlpha: (instanceId: number, track: number, alpha: number) => void
setTransformConstraintMix: (instanceId: number, name: string, mix: TransformMixData) => boolean
skeletonBounds: (skeletonHandle: number) => SpineAABB | null
unloadSkeleton: (handle: number) => void
update: (instanceId: number, dt: number) => void
static new (raw: SpineWasmModule, api: SpineWrappedAPI): SpineModuleController
static prototype: SpineModuleController

SpineModuleFactory — type @experimental

(config?: Record<string, unknown>) => Promise<SpineWasmModule>

SpinePair — interface @experimental

atlas: string
skeleton: string

SpinePlugin — class @experimental

build: (app: App) => void
cleanup: () => void
finish: (app: App) => void
name: string
setSpineManager: (manager: SpineManager) => void
spineManager: SpineManager | null
static new (manager?: SpineManager): SpinePlugin
static prototype: SpinePlugin

SpinePoseTotals — interface @experimental

logicalUpdates: number
meshExtractions: number
renderCulled: number
worldAlreadyCurrent: number
worldMaterializations: number

SpinePreviewInstance — interface @experimental

advance: (dt: number) => void
animations: () => string[]
clipBudget: () => SpineClipBudget | null
dispose: () => void
duration: (animation: string) => number
forEachMeshBatch: (visit: MeshBatchVisitor) => void
play: (animation: string) => void
setSkin: (skin: string) => void
skins: () => string[]

SpineResidencyFacts — interface @experimental

culling: SpineCullingEnvelope
entities: number
era: string
mayDefer: boolean
pair: SpinePair
requiresContinuousWorldPose: boolean

SpineRuntime — class @experimental

boneTree: (entity: Entity) => SkeletalBoneTree | null
clipBudget: (entity: Entity) => SpineClipBudget | null
collectAllEvents: (isActive?: (entity: Entity) => boolean) => { entity: Entity; raw: RawSpineEvent; }[]
dispose: () => void
enableEvents: (entity: Entity) => void
ensurePose: (entity: Entity) => boolean
entityCount: number
extractAndSubmitMeshes: (core: NonNullable<EngineApi>, registry: CppRegistry, materialOf?: SkeletalMaterialOf, isActive?: (entity: Entity) => boolean) => void
getAnimations: (entity: Entity) => string[]
getBounds: (entity: Entity) => { x: number; y: number; width: number; height: number; } | null
getPathConstraintMix: (entity: Entity, name: string) => PathMixData | null
getSkins: (entity: Entity) => string[]
getTransformConstraintMix: (entity: Entity, name: string) => TransformMixData | null
listConstraints: (entity: Entity) => ConstraintList | null
loadEntity: (entity: Entity, era: SpineEraBinding) => boolean
mayDefer: (entity: Entity) => boolean
metrics: () => SpineFrameMetrics | null
observe: (on: boolean) => void
observedBounds: (entity: Entity, sampleStep?: number) => SpineCullingEnvelope | null
openPreview: (era: SpineEraBinding) => SpinePreviewInstance | null
poseEligibility: (entity: Entity) => { culling: SpineCullingEnvelope; requiresContinuousWorldPose: boolean; } | null
removeEntity: (entity: Entity) => void
residencies: () => SpineResidencyFacts[]
setAnimation: (entity: Entity, animation: string, loop: boolean) => void
setAttachment: (entity: Entity, slotName: string, attachmentName: string) => boolean
setDefaultMix: (entity: Entity, duration: number) => void
setEnabled: (entity: Entity, enabled: boolean) => void
setEntityProps: (entity: Entity, props: { skeletonScale?: number; flipX?: boolean; flipY?: boolean; layer?: number; timeScale?: number; playing?: boolean; color?: { r: number; g: number; b: number; a: number; }; }) => void
setIKTarget: (entity: Entity, constraintName: string, targetX: number, targetY: number, mix: number) => boolean
setMixDuration: (entity: Entity, fromAnim: string, toAnim: string, duration: number) => void
setPathConstraintMix: (entity: Entity, name: string, mix: PathMixData) => boolean
setSkin: (entity: Entity, skin: string) => void
setSlotColor: (entity: Entity, slotName: string, r: number, g: number, b: number, a: number) => boolean
setTrackAlpha: (entity: Entity, track: number, alpha: number) => void
setTransformConstraintMix: (entity: Entity, name: string, mix: TransformMixData) => boolean
updateAll: (dt: number, isActive?: (entity: Entity) => boolean) => void
version: SpineVersion
windows: () => { pose: SpineTimeWindow; readback: SpineTimeWindow; total: SpineTimeWindow; }
worldPoseDebt: () => number
static new (version: SpineVersion, module: SpineWasmModule): SpineRuntime
static prototype: SpineRuntime

SpineScanCoverage — interface @experimental

animations: number
samples: number
skins: number

SpineSceneDiagnostics — interface @experimental

abi: SpineAbiCounts
assets: SpineAssetDiagnostic[]
bytes: SpineByteCounts
deferrable: number
entities: number
findings: SpineFinding[]
frame: number
geometry: { meshBatches: number; vertices: number; indices: number; }
observing: boolean
pose: SpinePoseTotals
runtimes: SpineRuntimeTiming[]
time: { pose: number; readback: number; total: number; }
worldPoseDebt: number

SpineVersion — type @experimental

'2.1' | '3.8' | '4.1' | '4.2' | '4.3'

TransformMixData — interface @experimental

mixRotate: number
mixScaleX: number
mixScaleY: number
mixShearY: number
mixX: number
mixY: number

applySpineEntities — function @experimental

(opts: { spineManager: SpineManager; sceneData: SceneData; entityMap: Map<number, Entity>; registry: CppRegistry; assetInfo: Map<string, SpineAssetInfo>; }): Promise<void>

certifyBounds — function @experimental

(bounds: SpineAABB): SpineCullingEnvelope

contains — function @experimental

(outer: SpineAABB, inner: SpineAABB): boolean

envelopeFor — function @experimental

(envelope: SpineCullingEnvelope, era: string): SpineCullingEnvelope

formatSpineDiagnostics — function @experimental

(d: SpineSceneDiagnostics): string

loadSpineAssets — function @experimental

(module: ESEngineModule | null, source: RuntimeAssetSource, spineManager: SpineManager | null | undefined, spinePairs: ReadonlyArray<{ skeleton: string; atlas: string; }>, transcoderProvider?: TranscoderProvider, owner?: SpineAssetOwner): Promise<Map<string, SpineAssetInfo>>

loadSpineSceneEntities — function @experimental

(opts: { module: ESEngineModule | null; source: RuntimeAssetSource; spineManager: SpineManager; sceneData: SceneData; entityMap: Map<number, Entity>; registry: CppRegistry; transcoderProvider?: TranscoderProvider; }): Promise<void>

mayDeferWorldPose — function @experimental

(envelope: SpineCullingEnvelope, requiresContinuousWorldPose: boolean): boolean

scanObservedBounds — function @experimental

(source: SpineBoundsSource, skeletonHandle: number, era: string, sampleStep?: number): SpineCullingEnvelope

setupBounds — function @experimental

(source: SpineBoundsSource, skeletonHandle: number): SpineAABB | null

spineCertificatesFrom — function @experimental

(source: SpineCullingProvider): SpineCertificateSource

spineEntityProps — function @experimental

(d: Record<string, unknown>): { skeletonScale: number; flipX: boolean; flipY: boolean; layer: number; timeScale: number; playing: boolean; color?: { r: number; g: number; b: number; a: number; }; }

spinePlugin — function @experimental

(manager?: SpineManager): SpinePlugin

spineSceneDiagnostics — function @experimental

(runtimes: Iterable<SpineDiagnosticRuntime>, observing: boolean): SpineSceneDiagnostics

worldBounds — function @experimental

(local: SpineAABB, transform: SpineAffine): SpineAABB

wrapSpineModule — function @experimental

(raw: SpineWasmModule): SpineWrappedAPI