mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-03-25 22:23:42 +08:00
78a730a6d7
* Rendering, added support for separate color/alpha src blend funcs. * LoadingScreen, set camera zoom to fade out and black flash, use PMA to fix ringing artifacts when scaled, fade in to help hide dropped frames as page loads, use separate color/alpha src blend funcs to properly blend quad when loading screen fades out, oxipng PNGs. * Moved some private constants out of their class to avoid class name prefix. * Player, clean up full pass OCD town, showError throws when possible so stacktrace isn't lost, added showLoading to config, don't create UI when !showControls, removed findWithId (id is unique for entire document), use built-in for findWithClass/contains, var->let, don't clear screen twice during loading, other minor stuff.
1907 lines
72 KiB
TypeScript
1907 lines
72 KiB
TypeScript
declare module spine {
|
|
class Animation {
|
|
name: string;
|
|
timelines: Array<Timeline>;
|
|
timelineIds: StringSet;
|
|
duration: number;
|
|
constructor(name: string, timelines: Array<Timeline>, duration: number);
|
|
setTimelines(timelines: Array<Timeline>): void;
|
|
hasTimeline(ids: string[]): boolean;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
enum MixBlend {
|
|
setup = 0,
|
|
first = 1,
|
|
replace = 2,
|
|
add = 3
|
|
}
|
|
enum MixDirection {
|
|
mixIn = 0,
|
|
mixOut = 1
|
|
}
|
|
abstract class Timeline {
|
|
propertyIds: string[];
|
|
frames: ArrayLike<number>;
|
|
constructor(frameCount: number, propertyIds: string[]);
|
|
getPropertyIds(): string[];
|
|
getFrameEntries(): number;
|
|
getFrameCount(): number;
|
|
getDuration(): number;
|
|
abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
static search1(frames: ArrayLike<number>, time: number): number;
|
|
static search(frames: ArrayLike<number>, time: number, step: number): number;
|
|
}
|
|
interface BoneTimeline {
|
|
boneIndex: number;
|
|
}
|
|
interface SlotTimeline {
|
|
slotIndex: number;
|
|
}
|
|
abstract class CurveTimeline extends Timeline {
|
|
protected curves: ArrayLike<number>;
|
|
constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
|
|
setLinear(frame: number): void;
|
|
setStepped(frame: number): void;
|
|
shrink(bezierCount: number): void;
|
|
setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
|
|
getBezierValue(time: number, frameIndex: number, valueOffset: number, i: number): number;
|
|
}
|
|
abstract class CurveTimeline1 extends CurveTimeline {
|
|
constructor(frameCount: number, bezierCount: number, propertyId: string);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, value: number): void;
|
|
getCurveValue(time: number): number;
|
|
}
|
|
abstract class CurveTimeline2 extends CurveTimeline {
|
|
constructor(frameCount: number, bezierCount: number, propertyId1: string, propertyId2: string);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, value1: number, value2: number): void;
|
|
}
|
|
class RotateTimeline extends CurveTimeline1 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class TranslateTimeline extends CurveTimeline2 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class TranslateXTimeline extends CurveTimeline1 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class TranslateYTimeline extends CurveTimeline1 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class ScaleTimeline extends CurveTimeline2 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class ScaleXTimeline extends CurveTimeline1 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class ScaleYTimeline extends CurveTimeline1 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class ShearTimeline extends CurveTimeline2 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class ShearXTimeline extends CurveTimeline1 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class ShearYTimeline extends CurveTimeline1 implements BoneTimeline {
|
|
boneIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, boneIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class RGBATimeline extends CurveTimeline implements SlotTimeline {
|
|
slotIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, slotIndex: number);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, r: number, g: number, b: number, a: number): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class RGBTimeline extends CurveTimeline implements SlotTimeline {
|
|
slotIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, slotIndex: number);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, r: number, g: number, b: number): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
|
|
slotIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, slotIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
|
|
slotIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, slotIndex: number);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class RGB2Timeline extends CurveTimeline implements SlotTimeline {
|
|
slotIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, slotIndex: number);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, r: number, g: number, b: number, r2: number, g2: number, b2: number): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class AttachmentTimeline extends Timeline implements SlotTimeline {
|
|
slotIndex: number;
|
|
attachmentNames: Array<string>;
|
|
constructor(frameCount: number, slotIndex: number);
|
|
getFrameCount(): number;
|
|
setFrame(frame: number, time: number, attachmentName: string): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
setAttachment(skeleton: Skeleton, slot: Slot, attachmentName: string): void;
|
|
}
|
|
class DeformTimeline extends CurveTimeline implements SlotTimeline {
|
|
slotIndex: number;
|
|
attachment: VertexAttachment;
|
|
vertices: Array<ArrayLike<number>>;
|
|
constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
|
|
getFrameCount(): number;
|
|
setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
|
|
setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
|
|
getCurvePercent(time: number, frame: number): number;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class EventTimeline extends Timeline {
|
|
static propertyIds: string[];
|
|
events: Array<Event>;
|
|
constructor(frameCount: number);
|
|
getFrameCount(): number;
|
|
setFrame(frame: number, event: Event): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class DrawOrderTimeline extends Timeline {
|
|
static propertyIds: string[];
|
|
drawOrders: Array<Array<number>>;
|
|
constructor(frameCount: number);
|
|
getFrameCount(): number;
|
|
setFrame(frame: number, time: number, drawOrder: Array<number>): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class IkConstraintTimeline extends CurveTimeline {
|
|
ikConstraintIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, ikConstraintIndex: number);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, mix: number, softness: number, bendDirection: number, compress: boolean, stretch: boolean): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class TransformConstraintTimeline extends CurveTimeline {
|
|
transformConstraintIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, transformConstraintIndex: number);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number, mixScaleX: number, mixScaleY: number, mixShearY: number): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class PathConstraintPositionTimeline extends CurveTimeline1 {
|
|
pathConstraintIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class PathConstraintSpacingTimeline extends CurveTimeline1 {
|
|
pathConstraintIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
class PathConstraintMixTimeline extends CurveTimeline {
|
|
pathConstraintIndex: number;
|
|
constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
|
|
getFrameEntries(): number;
|
|
setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
|
|
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class AnimationState {
|
|
private static emptyAnimation;
|
|
data: AnimationStateData;
|
|
tracks: TrackEntry[];
|
|
timeScale: number;
|
|
unkeyedState: number;
|
|
events: Event[];
|
|
listeners: AnimationStateListener[];
|
|
queue: EventQueue;
|
|
propertyIDs: StringSet;
|
|
animationsChanged: boolean;
|
|
trackEntryPool: Pool<TrackEntry>;
|
|
constructor(data: AnimationStateData);
|
|
update(delta: number): void;
|
|
updateMixingFrom(to: TrackEntry, delta: number): boolean;
|
|
apply(skeleton: Skeleton): boolean;
|
|
applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number;
|
|
applyAttachmentTimeline(timeline: AttachmentTimeline, skeleton: Skeleton, time: number, blend: MixBlend, attachments: boolean): void;
|
|
setAttachment(skeleton: Skeleton, slot: Slot, attachmentName: string, attachments: boolean): void;
|
|
applyRotateTimeline(timeline: RotateTimeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
|
|
queueEvents(entry: TrackEntry, animationTime: number): void;
|
|
clearTracks(): void;
|
|
clearTrack(trackIndex: number): void;
|
|
clearNext(entry: TrackEntry): void;
|
|
setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
|
|
setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
|
|
setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
|
|
addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
|
|
addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
|
|
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
|
|
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
|
|
setEmptyAnimations(mixDuration: number): void;
|
|
expandToIndex(index: number): TrackEntry;
|
|
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
|
|
disposeNext(entry: TrackEntry): void;
|
|
_animationsChanged(): void;
|
|
computeHold(entry: TrackEntry): void;
|
|
getCurrent(trackIndex: number): TrackEntry;
|
|
addListener(listener: AnimationStateListener): void;
|
|
removeListener(listener: AnimationStateListener): void;
|
|
clearListeners(): void;
|
|
clearListenerNotifications(): void;
|
|
}
|
|
class TrackEntry {
|
|
animation: Animation;
|
|
previous: TrackEntry;
|
|
next: TrackEntry;
|
|
mixingFrom: TrackEntry;
|
|
mixingTo: TrackEntry;
|
|
listener: AnimationStateListener;
|
|
trackIndex: number;
|
|
loop: boolean;
|
|
holdPrevious: boolean;
|
|
reverse: boolean;
|
|
eventThreshold: number;
|
|
attachmentThreshold: number;
|
|
drawOrderThreshold: number;
|
|
animationStart: number;
|
|
animationEnd: number;
|
|
animationLast: number;
|
|
nextAnimationLast: number;
|
|
delay: number;
|
|
trackTime: number;
|
|
trackLast: number;
|
|
nextTrackLast: number;
|
|
trackEnd: number;
|
|
timeScale: number;
|
|
alpha: number;
|
|
mixTime: number;
|
|
mixDuration: number;
|
|
interruptAlpha: number;
|
|
totalAlpha: number;
|
|
mixBlend: MixBlend;
|
|
timelineMode: number[];
|
|
timelineHoldMix: TrackEntry[];
|
|
timelinesRotation: number[];
|
|
reset(): void;
|
|
getAnimationTime(): number;
|
|
setAnimationLast(animationLast: number): void;
|
|
isComplete(): boolean;
|
|
resetRotationDirections(): void;
|
|
getTrackComplete(): number;
|
|
}
|
|
class EventQueue {
|
|
objects: Array<any>;
|
|
drainDisabled: boolean;
|
|
animState: AnimationState;
|
|
constructor(animState: AnimationState);
|
|
start(entry: TrackEntry): void;
|
|
interrupt(entry: TrackEntry): void;
|
|
end(entry: TrackEntry): void;
|
|
dispose(entry: TrackEntry): void;
|
|
complete(entry: TrackEntry): void;
|
|
event(entry: TrackEntry, event: Event): void;
|
|
drain(): void;
|
|
clear(): void;
|
|
}
|
|
enum EventType {
|
|
start = 0,
|
|
interrupt = 1,
|
|
end = 2,
|
|
dispose = 3,
|
|
complete = 4,
|
|
event = 5
|
|
}
|
|
interface AnimationStateListener {
|
|
start(entry: TrackEntry): void;
|
|
interrupt(entry: TrackEntry): void;
|
|
end(entry: TrackEntry): void;
|
|
dispose(entry: TrackEntry): void;
|
|
complete(entry: TrackEntry): void;
|
|
event(entry: TrackEntry, event: Event): void;
|
|
}
|
|
abstract class AnimationStateAdapter implements AnimationStateListener {
|
|
start(entry: TrackEntry): void;
|
|
interrupt(entry: TrackEntry): void;
|
|
end(entry: TrackEntry): void;
|
|
dispose(entry: TrackEntry): void;
|
|
complete(entry: TrackEntry): void;
|
|
event(entry: TrackEntry, event: Event): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class AnimationStateData {
|
|
skeletonData: SkeletonData;
|
|
animationToMixTime: Map<number>;
|
|
defaultMix: number;
|
|
constructor(skeletonData: SkeletonData);
|
|
setMix(fromName: string, toName: string, duration: number): void;
|
|
setMixWith(from: Animation, to: Animation, duration: number): void;
|
|
getMix(from: Animation, to: Animation): number;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class AssetManager implements Disposable {
|
|
private pathPrefix;
|
|
private textureLoader;
|
|
private downloader;
|
|
private assets;
|
|
private errors;
|
|
private toLoad;
|
|
private loaded;
|
|
constructor(textureLoader: (image: HTMLImageElement | ImageBitmap) => any, pathPrefix?: string, downloader?: Downloader);
|
|
private start;
|
|
private success;
|
|
private error;
|
|
setRawDataURI(path: string, data: string): void;
|
|
loadBinary(path: string, success?: (path: string, binary: Uint8Array) => void, error?: (path: string, message: string) => void): void;
|
|
loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, message: string) => void): void;
|
|
loadJson(path: string, success?: (path: string, object: object) => void, error?: (path: string, message: string) => void): void;
|
|
loadTexture(path: string, success?: (path: string, image: HTMLImageElement | ImageBitmap) => void, error?: (path: string, message: string) => void): void;
|
|
loadTextureAtlas(path: string, success?: (path: string, atlas: TextureAtlas) => void, error?: (path: string, message: string) => void): void;
|
|
get(path: string): any;
|
|
remove(path: string): any;
|
|
removeAll(): void;
|
|
isLoadingComplete(): boolean;
|
|
getToLoad(): number;
|
|
getLoaded(): number;
|
|
dispose(): void;
|
|
hasErrors(): boolean;
|
|
getErrors(): Map<string>;
|
|
}
|
|
class Downloader {
|
|
private callbacks;
|
|
rawDataUris: Map<string>;
|
|
downloadText(url: string, success: (data: string) => void, error: (status: number, responseText: string) => void): void;
|
|
downloadJson(url: string, success: (data: object) => void, error: (status: number, responseText: string) => void): void;
|
|
downloadBinary(url: string, success: (data: Uint8Array) => void, error: (status: number, responseText: string) => void): void;
|
|
private start;
|
|
private finish;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class AtlasAttachmentLoader implements AttachmentLoader {
|
|
atlas: TextureAtlas;
|
|
constructor(atlas: TextureAtlas);
|
|
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
|
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
|
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
|
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
|
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
|
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class Bone implements Updatable {
|
|
data: BoneData;
|
|
skeleton: Skeleton;
|
|
parent: Bone;
|
|
children: Bone[];
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
shearX: number;
|
|
shearY: number;
|
|
ax: number;
|
|
ay: number;
|
|
arotation: number;
|
|
ascaleX: number;
|
|
ascaleY: number;
|
|
ashearX: number;
|
|
ashearY: number;
|
|
a: number;
|
|
b: number;
|
|
c: number;
|
|
d: number;
|
|
worldY: number;
|
|
worldX: number;
|
|
sorted: boolean;
|
|
active: boolean;
|
|
constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
|
|
isActive(): boolean;
|
|
update(): void;
|
|
updateWorldTransform(): void;
|
|
updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number): void;
|
|
setToSetupPose(): void;
|
|
getWorldRotationX(): number;
|
|
getWorldRotationY(): number;
|
|
getWorldScaleX(): number;
|
|
getWorldScaleY(): number;
|
|
updateAppliedTransform(): void;
|
|
worldToLocal(world: Vector2): Vector2;
|
|
localToWorld(local: Vector2): Vector2;
|
|
worldToLocalRotation(worldRotation: number): number;
|
|
localToWorldRotation(localRotation: number): number;
|
|
rotateWorld(degrees: number): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class BoneData {
|
|
index: number;
|
|
name: string;
|
|
parent: BoneData;
|
|
length: number;
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
shearX: number;
|
|
shearY: number;
|
|
transformMode: TransformMode;
|
|
skinRequired: boolean;
|
|
color: Color;
|
|
constructor(index: number, name: string, parent: BoneData);
|
|
}
|
|
enum TransformMode {
|
|
Normal = 0,
|
|
OnlyTranslation = 1,
|
|
NoRotationOrReflection = 2,
|
|
NoScale = 3,
|
|
NoScaleOrReflection = 4
|
|
}
|
|
}
|
|
declare module spine {
|
|
abstract class ConstraintData {
|
|
name: string;
|
|
order: number;
|
|
skinRequired: boolean;
|
|
constructor(name: string, order: number, skinRequired: boolean);
|
|
}
|
|
}
|
|
declare module spine {
|
|
class Event {
|
|
data: EventData;
|
|
intValue: number;
|
|
floatValue: number;
|
|
stringValue: string;
|
|
time: number;
|
|
volume: number;
|
|
balance: number;
|
|
constructor(time: number, data: EventData);
|
|
}
|
|
}
|
|
declare module spine {
|
|
class EventData {
|
|
name: string;
|
|
intValue: number;
|
|
floatValue: number;
|
|
stringValue: string;
|
|
audioPath: string;
|
|
volume: number;
|
|
balance: number;
|
|
constructor(name: string);
|
|
}
|
|
}
|
|
declare module spine {
|
|
class IkConstraint implements Updatable {
|
|
data: IkConstraintData;
|
|
bones: Array<Bone>;
|
|
target: Bone;
|
|
bendDirection: number;
|
|
compress: boolean;
|
|
stretch: boolean;
|
|
mix: number;
|
|
softness: number;
|
|
active: boolean;
|
|
constructor(data: IkConstraintData, skeleton: Skeleton);
|
|
isActive(): boolean;
|
|
update(): void;
|
|
apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
|
|
apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, uniform: boolean, softness: number, alpha: number): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class IkConstraintData extends ConstraintData {
|
|
bones: BoneData[];
|
|
target: BoneData;
|
|
bendDirection: number;
|
|
compress: boolean;
|
|
stretch: boolean;
|
|
uniform: boolean;
|
|
mix: number;
|
|
softness: number;
|
|
constructor(name: string);
|
|
}
|
|
}
|
|
declare module spine {
|
|
class PathConstraint implements Updatable {
|
|
static NONE: number;
|
|
static BEFORE: number;
|
|
static AFTER: number;
|
|
static epsilon: number;
|
|
data: PathConstraintData;
|
|
bones: Array<Bone>;
|
|
target: Slot;
|
|
position: number;
|
|
spacing: number;
|
|
mixRotate: number;
|
|
mixX: number;
|
|
mixY: number;
|
|
spaces: number[];
|
|
positions: number[];
|
|
world: number[];
|
|
curves: number[];
|
|
lengths: number[];
|
|
segments: number[];
|
|
active: boolean;
|
|
constructor(data: PathConstraintData, skeleton: Skeleton);
|
|
isActive(): boolean;
|
|
update(): void;
|
|
computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean): number[];
|
|
addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
|
|
addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
|
|
addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class PathConstraintData extends ConstraintData {
|
|
bones: BoneData[];
|
|
target: SlotData;
|
|
positionMode: PositionMode;
|
|
spacingMode: SpacingMode;
|
|
rotateMode: RotateMode;
|
|
offsetRotation: number;
|
|
position: number;
|
|
spacing: number;
|
|
mixRotate: number;
|
|
mixX: number;
|
|
mixY: number;
|
|
constructor(name: string);
|
|
}
|
|
enum PositionMode {
|
|
Fixed = 0,
|
|
Percent = 1
|
|
}
|
|
enum SpacingMode {
|
|
Length = 0,
|
|
Fixed = 1,
|
|
Percent = 2,
|
|
Proportional = 3
|
|
}
|
|
enum RotateMode {
|
|
Tangent = 0,
|
|
Chain = 1,
|
|
ChainScale = 2
|
|
}
|
|
}
|
|
declare module spine {
|
|
class Skeleton {
|
|
data: SkeletonData;
|
|
bones: Array<Bone>;
|
|
slots: Array<Slot>;
|
|
drawOrder: Array<Slot>;
|
|
ikConstraints: Array<IkConstraint>;
|
|
transformConstraints: Array<TransformConstraint>;
|
|
pathConstraints: Array<PathConstraint>;
|
|
_updateCache: Updatable[];
|
|
skin: Skin;
|
|
color: Color;
|
|
time: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
x: number;
|
|
y: number;
|
|
constructor(data: SkeletonData);
|
|
updateCache(): void;
|
|
sortIkConstraint(constraint: IkConstraint): void;
|
|
sortPathConstraint(constraint: PathConstraint): void;
|
|
sortTransformConstraint(constraint: TransformConstraint): void;
|
|
sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
|
|
sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
|
|
sortBone(bone: Bone): void;
|
|
sortReset(bones: Array<Bone>): void;
|
|
updateWorldTransform(): void;
|
|
updateWorldTransformWith(parent: Bone): void;
|
|
setToSetupPose(): void;
|
|
setBonesToSetupPose(): void;
|
|
setSlotsToSetupPose(): void;
|
|
getRootBone(): Bone;
|
|
findBone(boneName: string): Bone;
|
|
findBoneIndex(boneName: string): number;
|
|
findSlot(slotName: string): Slot;
|
|
findSlotIndex(slotName: string): number;
|
|
setSkinByName(skinName: string): void;
|
|
setSkin(newSkin: Skin): void;
|
|
getAttachmentByName(slotName: string, attachmentName: string): Attachment;
|
|
getAttachment(slotIndex: number, attachmentName: string): Attachment;
|
|
setAttachment(slotName: string, attachmentName: string): void;
|
|
findIkConstraint(constraintName: string): IkConstraint;
|
|
findTransformConstraint(constraintName: string): TransformConstraint;
|
|
findPathConstraint(constraintName: string): PathConstraint;
|
|
getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
|
|
update(delta: number): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SkeletonBinary {
|
|
scale: number;
|
|
attachmentLoader: AttachmentLoader;
|
|
private linkedMeshes;
|
|
constructor(attachmentLoader: AttachmentLoader);
|
|
readSkeletonData(binary: Uint8Array): SkeletonData;
|
|
private readSkin;
|
|
private readAttachment;
|
|
private readVertices;
|
|
private readFloatArray;
|
|
private readShortArray;
|
|
private readAnimation;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SkeletonBounds {
|
|
minX: number;
|
|
minY: number;
|
|
maxX: number;
|
|
maxY: number;
|
|
boundingBoxes: BoundingBoxAttachment[];
|
|
polygons: ArrayLike<number>[];
|
|
private polygonPool;
|
|
update(skeleton: Skeleton, updateAabb: boolean): void;
|
|
aabbCompute(): void;
|
|
aabbContainsPoint(x: number, y: number): boolean;
|
|
aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
|
|
aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
|
|
containsPoint(x: number, y: number): BoundingBoxAttachment;
|
|
containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean;
|
|
intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
|
|
intersectsSegmentPolygon(polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number): boolean;
|
|
getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
|
|
getWidth(): number;
|
|
getHeight(): number;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SkeletonClipping {
|
|
private triangulator;
|
|
private clippingPolygon;
|
|
private clipOutput;
|
|
clippedVertices: number[];
|
|
clippedTriangles: number[];
|
|
private scratch;
|
|
private clipAttachment;
|
|
private clippingPolygons;
|
|
clipStart(slot: Slot, clip: ClippingAttachment): number;
|
|
clipEndWithSlot(slot: Slot): void;
|
|
clipEnd(): void;
|
|
isClipping(): boolean;
|
|
clipTriangles(vertices: ArrayLike<number>, verticesLength: number, triangles: ArrayLike<number>, trianglesLength: number, uvs: ArrayLike<number>, light: Color, dark: Color, twoColor: boolean): void;
|
|
clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
|
|
static makeClockwise(polygon: ArrayLike<number>): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SkeletonData {
|
|
name: string;
|
|
bones: BoneData[];
|
|
slots: SlotData[];
|
|
skins: Skin[];
|
|
defaultSkin: Skin;
|
|
events: EventData[];
|
|
animations: Animation[];
|
|
ikConstraints: IkConstraintData[];
|
|
transformConstraints: TransformConstraintData[];
|
|
pathConstraints: PathConstraintData[];
|
|
x: number;
|
|
y: number;
|
|
width: number;
|
|
height: number;
|
|
version: string;
|
|
hash: string;
|
|
fps: number;
|
|
imagesPath: string;
|
|
audioPath: string;
|
|
findBone(boneName: string): BoneData;
|
|
findBoneIndex(boneName: string): number;
|
|
findSlot(slotName: string): SlotData;
|
|
findSlotIndex(slotName: string): number;
|
|
findSkin(skinName: string): Skin;
|
|
findEvent(eventDataName: string): EventData;
|
|
findAnimation(animationName: string): Animation;
|
|
findIkConstraint(constraintName: string): IkConstraintData;
|
|
findTransformConstraint(constraintName: string): TransformConstraintData;
|
|
findPathConstraint(constraintName: string): PathConstraintData;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SkeletonJson {
|
|
attachmentLoader: AttachmentLoader;
|
|
scale: number;
|
|
private linkedMeshes;
|
|
constructor(attachmentLoader: AttachmentLoader);
|
|
readSkeletonData(json: string | any): SkeletonData;
|
|
readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment;
|
|
readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
|
|
readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SkinEntry {
|
|
slotIndex: number;
|
|
name: string;
|
|
attachment: Attachment;
|
|
constructor(slotIndex: number, name: string, attachment: Attachment);
|
|
}
|
|
class Skin {
|
|
name: string;
|
|
attachments: Map<Attachment>[];
|
|
bones: BoneData[];
|
|
constraints: ConstraintData[];
|
|
constructor(name: string);
|
|
setAttachment(slotIndex: number, name: string, attachment: Attachment): void;
|
|
addSkin(skin: Skin): void;
|
|
copySkin(skin: Skin): void;
|
|
getAttachment(slotIndex: number, name: string): Attachment;
|
|
removeAttachment(slotIndex: number, name: string): void;
|
|
getAttachments(): Array<SkinEntry>;
|
|
getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void;
|
|
clear(): void;
|
|
attachAll(skeleton: Skeleton, oldSkin: Skin): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class Slot {
|
|
data: SlotData;
|
|
bone: Bone;
|
|
color: Color;
|
|
darkColor: Color;
|
|
attachment: Attachment;
|
|
private attachmentTime;
|
|
attachmentState: number;
|
|
deform: number[];
|
|
constructor(data: SlotData, bone: Bone);
|
|
getSkeleton(): Skeleton;
|
|
getAttachment(): Attachment;
|
|
setAttachment(attachment: Attachment): void;
|
|
setAttachmentTime(time: number): void;
|
|
getAttachmentTime(): number;
|
|
setToSetupPose(): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SlotData {
|
|
index: number;
|
|
name: string;
|
|
boneData: BoneData;
|
|
color: Color;
|
|
darkColor: Color;
|
|
attachmentName: string;
|
|
blendMode: BlendMode;
|
|
constructor(index: number, name: string, boneData: BoneData);
|
|
}
|
|
enum BlendMode {
|
|
Normal = 0,
|
|
Additive = 1,
|
|
Multiply = 2,
|
|
Screen = 3
|
|
}
|
|
}
|
|
declare module spine {
|
|
abstract class Texture {
|
|
protected _image: HTMLImageElement | ImageBitmap;
|
|
constructor(image: HTMLImageElement | ImageBitmap);
|
|
getImage(): HTMLImageElement | ImageBitmap;
|
|
abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
|
abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
|
abstract dispose(): void;
|
|
}
|
|
enum TextureFilter {
|
|
Nearest = 9728,
|
|
Linear = 9729,
|
|
MipMap = 9987,
|
|
MipMapNearestNearest = 9984,
|
|
MipMapLinearNearest = 9985,
|
|
MipMapNearestLinear = 9986,
|
|
MipMapLinearLinear = 9987
|
|
}
|
|
enum TextureWrap {
|
|
MirroredRepeat = 33648,
|
|
ClampToEdge = 33071,
|
|
Repeat = 10497
|
|
}
|
|
class TextureRegion {
|
|
renderObject: any;
|
|
u: number;
|
|
v: number;
|
|
u2: number;
|
|
v2: number;
|
|
width: number;
|
|
height: number;
|
|
degrees: number;
|
|
offsetX: number;
|
|
offsetY: number;
|
|
originalWidth: number;
|
|
originalHeight: number;
|
|
}
|
|
class FakeTexture extends Texture {
|
|
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
|
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
|
dispose(): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class TextureAtlas implements Disposable {
|
|
pages: TextureAtlasPage[];
|
|
regions: TextureAtlasRegion[];
|
|
constructor(atlasText: string, textureLoader: (path: string) => any);
|
|
private load;
|
|
findRegion(name: string): TextureAtlasRegion;
|
|
dispose(): void;
|
|
}
|
|
class TextureAtlasPage {
|
|
name: string;
|
|
minFilter: TextureFilter;
|
|
magFilter: TextureFilter;
|
|
uWrap: TextureWrap;
|
|
vWrap: TextureWrap;
|
|
texture: Texture;
|
|
width: number;
|
|
height: number;
|
|
pma: boolean;
|
|
}
|
|
class TextureAtlasRegion extends TextureRegion {
|
|
page: TextureAtlasPage;
|
|
name: string;
|
|
x: number;
|
|
y: number;
|
|
offsetX: number;
|
|
offsetY: number;
|
|
originalWidth: number;
|
|
originalHeight: number;
|
|
index: number;
|
|
degrees: number;
|
|
texture: Texture;
|
|
names: string[];
|
|
values: number[][];
|
|
}
|
|
}
|
|
declare module spine {
|
|
class TransformConstraint implements Updatable {
|
|
data: TransformConstraintData;
|
|
bones: Array<Bone>;
|
|
target: Bone;
|
|
mixRotate: number;
|
|
mixX: number;
|
|
mixY: number;
|
|
mixScaleX: number;
|
|
mixScaleY: number;
|
|
mixShearY: number;
|
|
temp: Vector2;
|
|
active: boolean;
|
|
constructor(data: TransformConstraintData, skeleton: Skeleton);
|
|
isActive(): boolean;
|
|
update(): void;
|
|
applyAbsoluteWorld(): void;
|
|
applyRelativeWorld(): void;
|
|
applyAbsoluteLocal(): void;
|
|
applyRelativeLocal(): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class TransformConstraintData extends ConstraintData {
|
|
bones: BoneData[];
|
|
target: BoneData;
|
|
mixRotate: number;
|
|
mixX: number;
|
|
mixY: number;
|
|
mixScaleX: number;
|
|
mixScaleY: number;
|
|
mixShearY: number;
|
|
offsetRotation: number;
|
|
offsetX: number;
|
|
offsetY: number;
|
|
offsetScaleX: number;
|
|
offsetScaleY: number;
|
|
offsetShearY: number;
|
|
relative: boolean;
|
|
local: boolean;
|
|
constructor(name: string);
|
|
}
|
|
}
|
|
declare module spine {
|
|
class Triangulator {
|
|
private convexPolygons;
|
|
private convexPolygonsIndices;
|
|
private indicesArray;
|
|
private isConcaveArray;
|
|
private triangles;
|
|
private polygonPool;
|
|
private polygonIndicesPool;
|
|
triangulate(verticesArray: ArrayLike<number>): Array<number>;
|
|
decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
|
|
private static isConcave;
|
|
private static positiveArea;
|
|
private static winding;
|
|
}
|
|
}
|
|
declare module spine {
|
|
interface Updatable {
|
|
update(): void;
|
|
isActive(): boolean;
|
|
}
|
|
}
|
|
declare module spine {
|
|
interface Map<T> {
|
|
[key: string]: T;
|
|
}
|
|
class IntSet {
|
|
array: number[];
|
|
add(value: number): boolean;
|
|
contains(value: number): boolean;
|
|
remove(value: number): void;
|
|
clear(): void;
|
|
}
|
|
class StringSet {
|
|
entries: Map<boolean>;
|
|
size: number;
|
|
add(value: string): boolean;
|
|
addAll(values: string[]): boolean;
|
|
contains(value: string): boolean;
|
|
clear(): void;
|
|
}
|
|
interface Disposable {
|
|
dispose(): void;
|
|
}
|
|
interface Restorable {
|
|
restore(): void;
|
|
}
|
|
class Color {
|
|
r: number;
|
|
g: number;
|
|
b: number;
|
|
a: number;
|
|
static WHITE: Color;
|
|
static RED: Color;
|
|
static GREEN: Color;
|
|
static BLUE: Color;
|
|
static MAGENTA: Color;
|
|
constructor(r?: number, g?: number, b?: number, a?: number);
|
|
set(r: number, g: number, b: number, a: number): this;
|
|
setFromColor(c: Color): this;
|
|
setFromString(hex: string): this;
|
|
add(r: number, g: number, b: number, a: number): this;
|
|
clamp(): this;
|
|
static rgba8888ToColor(color: Color, value: number): void;
|
|
static rgb888ToColor(color: Color, value: number): void;
|
|
static fromString(hex: string): Color;
|
|
}
|
|
class MathUtils {
|
|
static PI: number;
|
|
static PI2: number;
|
|
static radiansToDegrees: number;
|
|
static radDeg: number;
|
|
static degreesToRadians: number;
|
|
static degRad: number;
|
|
static clamp(value: number, min: number, max: number): number;
|
|
static cosDeg(degrees: number): number;
|
|
static sinDeg(degrees: number): number;
|
|
static signum(value: number): number;
|
|
static toInt(x: number): number;
|
|
static cbrt(x: number): number;
|
|
static randomTriangular(min: number, max: number): number;
|
|
static randomTriangularWith(min: number, max: number, mode: number): number;
|
|
}
|
|
abstract class Interpolation {
|
|
protected abstract applyInternal(a: number): number;
|
|
apply(start: number, end: number, a: number): number;
|
|
}
|
|
class Pow extends Interpolation {
|
|
protected power: number;
|
|
constructor(power: number);
|
|
applyInternal(a: number): number;
|
|
}
|
|
class PowOut extends Pow {
|
|
constructor(power: number);
|
|
applyInternal(a: number): number;
|
|
}
|
|
class Utils {
|
|
static SUPPORTS_TYPED_ARRAYS: boolean;
|
|
static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number): void;
|
|
static arrayFill<T>(array: ArrayLike<T>, fromIndex: number, toIndex: number, value: T): void;
|
|
static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>;
|
|
static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>;
|
|
static newArray<T>(size: number, defaultValue: T): Array<T>;
|
|
static newFloatArray(size: number): ArrayLike<number>;
|
|
static newShortArray(size: number): ArrayLike<number>;
|
|
static toFloatArray(array: Array<number>): number[] | Float32Array;
|
|
static toSinglePrecision(value: number): number;
|
|
static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
|
|
static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
|
|
static enumValue(type: any, name: string): any;
|
|
}
|
|
class DebugUtils {
|
|
static logBones(skeleton: Skeleton): void;
|
|
}
|
|
class Pool<T> {
|
|
private items;
|
|
private instantiator;
|
|
constructor(instantiator: () => T);
|
|
obtain(): T;
|
|
free(item: T): void;
|
|
freeAll(items: ArrayLike<T>): void;
|
|
clear(): void;
|
|
}
|
|
class Vector2 {
|
|
x: number;
|
|
y: number;
|
|
constructor(x?: number, y?: number);
|
|
set(x: number, y: number): Vector2;
|
|
length(): number;
|
|
normalize(): this;
|
|
}
|
|
class TimeKeeper {
|
|
maxDelta: number;
|
|
framesPerSecond: number;
|
|
delta: number;
|
|
totalTime: number;
|
|
private lastTime;
|
|
private frameCount;
|
|
private frameTime;
|
|
update(): void;
|
|
}
|
|
interface ArrayLike<T> {
|
|
length: number;
|
|
[n: number]: T;
|
|
}
|
|
class WindowedMean {
|
|
values: Array<number>;
|
|
addedValues: number;
|
|
lastValue: number;
|
|
mean: number;
|
|
dirty: boolean;
|
|
constructor(windowSize?: number);
|
|
hasEnoughData(): boolean;
|
|
addValue(value: number): void;
|
|
getMean(): number;
|
|
}
|
|
}
|
|
declare module spine {
|
|
interface VertexEffect {
|
|
begin(skeleton: Skeleton): void;
|
|
transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
|
|
end(): void;
|
|
}
|
|
}
|
|
interface Math {
|
|
fround(n: number): number;
|
|
}
|
|
declare module spine {
|
|
abstract class Attachment {
|
|
name: string;
|
|
constructor(name: string);
|
|
abstract copy(): Attachment;
|
|
}
|
|
abstract class VertexAttachment extends Attachment {
|
|
private static nextID;
|
|
id: number;
|
|
bones: Array<number>;
|
|
vertices: ArrayLike<number>;
|
|
worldVerticesLength: number;
|
|
deformAttachment: VertexAttachment;
|
|
constructor(name: string);
|
|
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
|
copyTo(attachment: VertexAttachment): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
interface AttachmentLoader {
|
|
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
|
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
|
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
|
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
|
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
|
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class BoundingBoxAttachment extends VertexAttachment {
|
|
color: Color;
|
|
constructor(name: string);
|
|
copy(): Attachment;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class ClippingAttachment extends VertexAttachment {
|
|
endSlot: SlotData;
|
|
color: Color;
|
|
constructor(name: string);
|
|
copy(): Attachment;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class MeshAttachment extends VertexAttachment {
|
|
region: TextureRegion;
|
|
path: string;
|
|
regionUVs: ArrayLike<number>;
|
|
uvs: ArrayLike<number>;
|
|
triangles: Array<number>;
|
|
color: Color;
|
|
width: number;
|
|
height: number;
|
|
hullLength: number;
|
|
edges: Array<number>;
|
|
private parentMesh;
|
|
tempColor: Color;
|
|
constructor(name: string);
|
|
updateUVs(): void;
|
|
getParentMesh(): MeshAttachment;
|
|
setParentMesh(parentMesh: MeshAttachment): void;
|
|
copy(): Attachment;
|
|
newLinkedMesh(): MeshAttachment;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class PathAttachment extends VertexAttachment {
|
|
lengths: Array<number>;
|
|
closed: boolean;
|
|
constantSpeed: boolean;
|
|
color: Color;
|
|
constructor(name: string);
|
|
copy(): Attachment;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class PointAttachment extends VertexAttachment {
|
|
x: number;
|
|
y: number;
|
|
rotation: number;
|
|
color: Color;
|
|
constructor(name: string);
|
|
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
|
computeWorldRotation(bone: Bone): number;
|
|
copy(): Attachment;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class RegionAttachment extends Attachment {
|
|
x: number;
|
|
y: number;
|
|
scaleX: number;
|
|
scaleY: number;
|
|
rotation: number;
|
|
width: number;
|
|
height: number;
|
|
color: Color;
|
|
path: string;
|
|
rendererObject: any;
|
|
region: TextureRegion;
|
|
offset: ArrayLike<number>;
|
|
uvs: ArrayLike<number>;
|
|
tempColor: Color;
|
|
constructor(name: string);
|
|
updateOffset(): void;
|
|
setRegion(region: TextureRegion): void;
|
|
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
|
copy(): Attachment;
|
|
static X1: number;
|
|
static Y1: number;
|
|
static C1R: number;
|
|
static C1G: number;
|
|
static C1B: number;
|
|
static C1A: number;
|
|
static U1: number;
|
|
static V1: number;
|
|
static X2: number;
|
|
static Y2: number;
|
|
static C2R: number;
|
|
static C2G: number;
|
|
static C2B: number;
|
|
static C2A: number;
|
|
static U2: number;
|
|
static V2: number;
|
|
static X3: number;
|
|
static Y3: number;
|
|
static C3R: number;
|
|
static C3G: number;
|
|
static C3B: number;
|
|
static C3A: number;
|
|
static U3: number;
|
|
static V3: number;
|
|
static X4: number;
|
|
static Y4: number;
|
|
static C4R: number;
|
|
static C4G: number;
|
|
static C4B: number;
|
|
static C4A: number;
|
|
static U4: number;
|
|
static V4: number;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class JitterEffect implements VertexEffect {
|
|
jitterX: number;
|
|
jitterY: number;
|
|
constructor(jitterX: number, jitterY: number);
|
|
begin(skeleton: Skeleton): void;
|
|
transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
|
|
end(): void;
|
|
}
|
|
}
|
|
declare module spine {
|
|
class SwirlEffect implements VertexEffect {
|
|
static interpolation: PowOut;
|
|
centerX: number;
|
|
centerY: number;
|
|
radius: number;
|
|
angle: number;
|
|
private worldX;
|
|
private worldY;
|
|
constructor(radius: number);
|
|
begin(skeleton: Skeleton): void;
|
|
transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
|
|
end(): void;
|
|
}
|
|
}
|
|
declare module spine.canvas {
|
|
class AssetManager extends spine.AssetManager {
|
|
constructor(pathPrefix?: string, downloader?: Downloader);
|
|
}
|
|
}
|
|
declare module spine.canvas {
|
|
class CanvasTexture extends Texture {
|
|
constructor(image: HTMLImageElement);
|
|
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
|
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
|
dispose(): void;
|
|
}
|
|
}
|
|
declare module spine.canvas {
|
|
class SkeletonRenderer {
|
|
static QUAD_TRIANGLES: number[];
|
|
static VERTEX_SIZE: number;
|
|
private ctx;
|
|
triangleRendering: boolean;
|
|
debugRendering: boolean;
|
|
private vertices;
|
|
private tempColor;
|
|
constructor(context: CanvasRenderingContext2D);
|
|
draw(skeleton: Skeleton): void;
|
|
private drawImages;
|
|
private drawTriangles;
|
|
private drawTriangle;
|
|
private computeRegionVertices;
|
|
private computeMeshVertices;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class AssetManager extends spine.AssetManager {
|
|
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string, downloader?: Downloader);
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class OrthoCamera {
|
|
position: Vector3;
|
|
direction: Vector3;
|
|
up: Vector3;
|
|
near: number;
|
|
far: number;
|
|
zoom: number;
|
|
viewportWidth: number;
|
|
viewportHeight: number;
|
|
projectionView: Matrix4;
|
|
inverseProjectionView: Matrix4;
|
|
projection: Matrix4;
|
|
view: Matrix4;
|
|
private tmp;
|
|
constructor(viewportWidth: number, viewportHeight: number);
|
|
update(): void;
|
|
screenToWorld(screenCoords: Vector3, screenWidth: number, screenHeight: number): Vector3;
|
|
setViewport(viewportWidth: number, viewportHeight: number): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class GLTexture extends Texture implements Disposable, Restorable {
|
|
private context;
|
|
private texture;
|
|
private boundUnit;
|
|
private useMipMaps;
|
|
static DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL: boolean;
|
|
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement | ImageBitmap, useMipMaps?: boolean);
|
|
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
|
static validateMagFilter(magFilter: TextureFilter): TextureFilter.Nearest | TextureFilter.Linear;
|
|
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
|
update(useMipMaps: boolean): void;
|
|
restore(): void;
|
|
bind(unit?: number): void;
|
|
unbind(): void;
|
|
dispose(): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class Input {
|
|
element: HTMLElement;
|
|
lastX: number;
|
|
lastY: number;
|
|
buttonDown: boolean;
|
|
currTouch: Touch;
|
|
touchesPool: Pool<Touch>;
|
|
private listeners;
|
|
constructor(element: HTMLElement);
|
|
private setupCallbacks;
|
|
addListener(listener: InputListener): void;
|
|
removeListener(listener: InputListener): void;
|
|
}
|
|
class Touch {
|
|
identifier: number;
|
|
x: number;
|
|
y: number;
|
|
constructor(identifier: number, x: number, y: number);
|
|
}
|
|
interface InputListener {
|
|
down(x: number, y: number): void;
|
|
up(x: number, y: number): void;
|
|
moved(x: number, y: number): void;
|
|
dragged(x: number, y: number): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class LoadingScreen {
|
|
private renderer;
|
|
private logo;
|
|
private spinner;
|
|
private angle;
|
|
private fadeOut;
|
|
private fadeIn;
|
|
private timeKeeper;
|
|
backgroundColor: Color;
|
|
private tempColor;
|
|
constructor(renderer: SceneRenderer);
|
|
draw(complete?: boolean): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
const M00 = 0;
|
|
const M01 = 4;
|
|
const M02 = 8;
|
|
const M03 = 12;
|
|
const M10 = 1;
|
|
const M11 = 5;
|
|
const M12 = 9;
|
|
const M13 = 13;
|
|
const M20 = 2;
|
|
const M21 = 6;
|
|
const M22 = 10;
|
|
const M23 = 14;
|
|
const M30 = 3;
|
|
const M31 = 7;
|
|
const M32 = 11;
|
|
const M33 = 15;
|
|
class Matrix4 {
|
|
temp: Float32Array;
|
|
values: Float32Array;
|
|
private static xAxis;
|
|
private static yAxis;
|
|
private static zAxis;
|
|
private static tmpMatrix;
|
|
constructor();
|
|
set(values: ArrayLike<number>): Matrix4;
|
|
transpose(): Matrix4;
|
|
identity(): Matrix4;
|
|
invert(): Matrix4;
|
|
determinant(): number;
|
|
translate(x: number, y: number, z: number): Matrix4;
|
|
copy(): Matrix4;
|
|
projection(near: number, far: number, fovy: number, aspectRatio: number): Matrix4;
|
|
ortho2d(x: number, y: number, width: number, height: number): Matrix4;
|
|
ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
|
|
multiply(matrix: Matrix4): Matrix4;
|
|
multiplyLeft(matrix: Matrix4): Matrix4;
|
|
lookAt(position: Vector3, direction: Vector3, up: Vector3): this;
|
|
static initTemps(): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class Mesh implements Disposable, Restorable {
|
|
private attributes;
|
|
private context;
|
|
private vertices;
|
|
private verticesBuffer;
|
|
private verticesLength;
|
|
private dirtyVertices;
|
|
private indices;
|
|
private indicesBuffer;
|
|
private indicesLength;
|
|
private dirtyIndices;
|
|
private elementsPerVertex;
|
|
getAttributes(): VertexAttribute[];
|
|
maxVertices(): number;
|
|
numVertices(): number;
|
|
setVerticesLength(length: number): void;
|
|
getVertices(): Float32Array;
|
|
maxIndices(): number;
|
|
numIndices(): number;
|
|
setIndicesLength(length: number): void;
|
|
getIndices(): Uint16Array;
|
|
getVertexSizeInFloats(): number;
|
|
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, attributes: VertexAttribute[], maxVertices: number, maxIndices: number);
|
|
setVertices(vertices: Array<number>): void;
|
|
setIndices(indices: Array<number>): void;
|
|
draw(shader: Shader, primitiveType: number): void;
|
|
drawWithOffset(shader: Shader, primitiveType: number, offset: number, count: number): void;
|
|
bind(shader: Shader): void;
|
|
unbind(shader: Shader): void;
|
|
private update;
|
|
restore(): void;
|
|
dispose(): void;
|
|
}
|
|
class VertexAttribute {
|
|
name: string;
|
|
type: VertexAttributeType;
|
|
numElements: number;
|
|
constructor(name: string, type: VertexAttributeType, numElements: number);
|
|
}
|
|
class Position2Attribute extends VertexAttribute {
|
|
constructor();
|
|
}
|
|
class Position3Attribute extends VertexAttribute {
|
|
constructor();
|
|
}
|
|
class TexCoordAttribute extends VertexAttribute {
|
|
constructor(unit?: number);
|
|
}
|
|
class ColorAttribute extends VertexAttribute {
|
|
constructor();
|
|
}
|
|
class Color2Attribute extends VertexAttribute {
|
|
constructor();
|
|
}
|
|
enum VertexAttributeType {
|
|
Float = 0
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class PolygonBatcher implements Disposable {
|
|
private context;
|
|
private drawCalls;
|
|
private isDrawing;
|
|
private mesh;
|
|
private shader;
|
|
private lastTexture;
|
|
private verticesLength;
|
|
private indicesLength;
|
|
private srcColorBlend;
|
|
private srcAlphaBlend;
|
|
private dstBlend;
|
|
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean, maxVertices?: number);
|
|
begin(shader: Shader): void;
|
|
setBlendMode(srcColorBlend: number, srcAlphaBlend: number, dstBlend: number): void;
|
|
draw(texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>): void;
|
|
private flush;
|
|
end(): void;
|
|
getDrawCalls(): number;
|
|
dispose(): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class SceneRenderer implements Disposable {
|
|
context: ManagedWebGLRenderingContext;
|
|
canvas: HTMLCanvasElement;
|
|
camera: OrthoCamera;
|
|
batcher: PolygonBatcher;
|
|
private twoColorTint;
|
|
private batcherShader;
|
|
private shapes;
|
|
private shapesShader;
|
|
private activeRenderer;
|
|
skeletonRenderer: SkeletonRenderer;
|
|
skeletonDebugRenderer: SkeletonDebugRenderer;
|
|
constructor(canvas: HTMLCanvasElement, context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean);
|
|
begin(): void;
|
|
drawSkeleton(skeleton: Skeleton, premultipliedAlpha?: boolean, slotRangeStart?: number, slotRangeEnd?: number): void;
|
|
drawSkeletonDebug(skeleton: Skeleton, premultipliedAlpha?: boolean, ignoredBones?: Array<string>): void;
|
|
drawTexture(texture: GLTexture, x: number, y: number, width: number, height: number, color?: Color): void;
|
|
drawTextureUV(texture: GLTexture, x: number, y: number, width: number, height: number, u: number, v: number, u2: number, v2: number, color?: Color): void;
|
|
drawTextureRotated(texture: GLTexture, x: number, y: number, width: number, height: number, pivotX: number, pivotY: number, angle: number, color?: Color): void;
|
|
drawRegion(region: TextureAtlasRegion, x: number, y: number, width: number, height: number, color?: Color): void;
|
|
line(x: number, y: number, x2: number, y2: number, color?: Color, color2?: Color): void;
|
|
triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
|
|
quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
|
|
rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
|
|
rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
|
|
polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
|
|
circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
|
|
curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
|
|
end(): void;
|
|
resize(resizeMode: ResizeMode): void;
|
|
private enableRenderer;
|
|
dispose(): void;
|
|
}
|
|
enum ResizeMode {
|
|
Stretch = 0,
|
|
Expand = 1,
|
|
Fit = 2
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class Shader implements Disposable, Restorable {
|
|
private vertexShader;
|
|
private fragmentShader;
|
|
static MVP_MATRIX: string;
|
|
static POSITION: string;
|
|
static COLOR: string;
|
|
static COLOR2: string;
|
|
static TEXCOORDS: string;
|
|
static SAMPLER: string;
|
|
private context;
|
|
private vs;
|
|
private vsSource;
|
|
private fs;
|
|
private fsSource;
|
|
private program;
|
|
private tmp2x2;
|
|
private tmp3x3;
|
|
private tmp4x4;
|
|
getProgram(): WebGLProgram;
|
|
getVertexShader(): string;
|
|
getFragmentShader(): string;
|
|
getVertexShaderSource(): string;
|
|
getFragmentSource(): string;
|
|
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, vertexShader: string, fragmentShader: string);
|
|
private compile;
|
|
private compileShader;
|
|
private compileProgram;
|
|
restore(): void;
|
|
bind(): void;
|
|
unbind(): void;
|
|
setUniformi(uniform: string, value: number): void;
|
|
setUniformf(uniform: string, value: number): void;
|
|
setUniform2f(uniform: string, value: number, value2: number): void;
|
|
setUniform3f(uniform: string, value: number, value2: number, value3: number): void;
|
|
setUniform4f(uniform: string, value: number, value2: number, value3: number, value4: number): void;
|
|
setUniform2x2f(uniform: string, value: ArrayLike<number>): void;
|
|
setUniform3x3f(uniform: string, value: ArrayLike<number>): void;
|
|
setUniform4x4f(uniform: string, value: ArrayLike<number>): void;
|
|
getUniformLocation(uniform: string): WebGLUniformLocation;
|
|
getAttributeLocation(attribute: string): number;
|
|
dispose(): void;
|
|
static newColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
|
|
static newTwoColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
|
|
static newColored(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class ShapeRenderer implements Disposable {
|
|
private context;
|
|
private isDrawing;
|
|
private mesh;
|
|
private shapeType;
|
|
private color;
|
|
private shader;
|
|
private vertexIndex;
|
|
private tmp;
|
|
private srcColorBlend;
|
|
private srcAlphaBlend;
|
|
private dstBlend;
|
|
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices?: number);
|
|
begin(shader: Shader): void;
|
|
setBlendMode(srcColorBlend: number, srcAlphaBlend: number, dstBlend: number): void;
|
|
setColor(color: Color): void;
|
|
setColorWith(r: number, g: number, b: number, a: number): void;
|
|
point(x: number, y: number, color?: Color): void;
|
|
line(x: number, y: number, x2: number, y2: number, color?: Color): void;
|
|
triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
|
|
quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
|
|
rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
|
|
rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
|
|
x(x: number, y: number, size: number): void;
|
|
polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
|
|
circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
|
|
curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
|
|
private vertex;
|
|
end(): void;
|
|
private flush;
|
|
private check;
|
|
dispose(): void;
|
|
}
|
|
enum ShapeType {
|
|
Point = 0,
|
|
Line = 1,
|
|
Filled = 4
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class SkeletonDebugRenderer implements Disposable {
|
|
boneLineColor: Color;
|
|
boneOriginColor: Color;
|
|
attachmentLineColor: Color;
|
|
triangleLineColor: Color;
|
|
pathColor: Color;
|
|
clipColor: Color;
|
|
aabbColor: Color;
|
|
drawBones: boolean;
|
|
drawRegionAttachments: boolean;
|
|
drawBoundingBoxes: boolean;
|
|
drawMeshHull: boolean;
|
|
drawMeshTriangles: boolean;
|
|
drawPaths: boolean;
|
|
drawSkeletonXY: boolean;
|
|
drawClipping: boolean;
|
|
premultipliedAlpha: boolean;
|
|
scale: number;
|
|
boneWidth: number;
|
|
private context;
|
|
private bounds;
|
|
private temp;
|
|
private vertices;
|
|
private static LIGHT_GRAY;
|
|
private static GREEN;
|
|
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext);
|
|
draw(shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones?: Array<string>): void;
|
|
dispose(): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class SkeletonRenderer {
|
|
static QUAD_TRIANGLES: number[];
|
|
premultipliedAlpha: boolean;
|
|
vertexEffect: VertexEffect;
|
|
private tempColor;
|
|
private tempColor2;
|
|
private vertices;
|
|
private vertexSize;
|
|
private twoColorTint;
|
|
private renderable;
|
|
private clipper;
|
|
private temp;
|
|
private temp2;
|
|
private temp3;
|
|
private temp4;
|
|
constructor(context: ManagedWebGLRenderingContext, twoColorTint?: boolean);
|
|
draw(batcher: PolygonBatcher, skeleton: Skeleton, slotRangeStart?: number, slotRangeEnd?: number): void;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class Vector3 {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
constructor(x?: number, y?: number, z?: number);
|
|
setFrom(v: Vector3): Vector3;
|
|
set(x: number, y: number, z: number): Vector3;
|
|
add(v: Vector3): Vector3;
|
|
sub(v: Vector3): Vector3;
|
|
scale(s: number): Vector3;
|
|
normalize(): Vector3;
|
|
cross(v: Vector3): Vector3;
|
|
multiply(matrix: Matrix4): Vector3;
|
|
project(matrix: Matrix4): Vector3;
|
|
dot(v: Vector3): number;
|
|
length(): number;
|
|
distance(v: Vector3): number;
|
|
}
|
|
}
|
|
declare module spine.webgl {
|
|
class ManagedWebGLRenderingContext {
|
|
canvas: HTMLCanvasElement | OffscreenCanvas;
|
|
gl: WebGLRenderingContext;
|
|
private restorables;
|
|
constructor(canvasOrContext: HTMLCanvasElement | WebGLRenderingContext | EventTarget | WebGL2RenderingContext, contextConfig?: any);
|
|
private setupCanvas;
|
|
addRestorable(restorable: Restorable): void;
|
|
removeRestorable(restorable: Restorable): void;
|
|
}
|
|
class WebGLBlendModeConverter {
|
|
static getDestGLBlendMode(blendMode: BlendMode): 1 | 771;
|
|
static getSourceColorGLBlendMode(blendMode: BlendMode, premultipliedAlpha?: boolean): 1 | 770 | 774;
|
|
static getSourceAlphaGLBlendMode(blendMode: BlendMode): 1 | 771 | 769;
|
|
}
|
|
}
|
|
declare module spine.threejs {
|
|
class AssetManager extends spine.AssetManager {
|
|
constructor(pathPrefix?: string, downloader?: Downloader);
|
|
}
|
|
}
|
|
declare module spine.threejs {
|
|
class MeshBatcher extends THREE.Mesh {
|
|
private static VERTEX_SIZE;
|
|
private vertexBuffer;
|
|
private vertices;
|
|
private verticesLength;
|
|
private indices;
|
|
private indicesLength;
|
|
constructor(maxVertices?: number, materialCustomizer?: SkeletonMeshMaterialParametersCustomizer);
|
|
dispose(): void;
|
|
clear(): void;
|
|
begin(): void;
|
|
canBatch(verticesLength: number, indicesLength: number): boolean;
|
|
batch(vertices: ArrayLike<number>, verticesLength: number, indices: ArrayLike<number>, indicesLength: number, z?: number): void;
|
|
end(): void;
|
|
}
|
|
}
|
|
declare module spine.threejs {
|
|
interface SkeletonMeshMaterialParametersCustomizer {
|
|
(materialParameters: THREE.ShaderMaterialParameters): void;
|
|
}
|
|
class SkeletonMeshMaterial extends THREE.ShaderMaterial {
|
|
constructor(customizer: SkeletonMeshMaterialParametersCustomizer);
|
|
}
|
|
class SkeletonMesh extends THREE.Object3D {
|
|
tempPos: Vector2;
|
|
tempUv: Vector2;
|
|
tempLight: Color;
|
|
tempDark: Color;
|
|
skeleton: Skeleton;
|
|
state: AnimationState;
|
|
zOffset: number;
|
|
vertexEffect: VertexEffect;
|
|
private batches;
|
|
private nextBatchIndex;
|
|
private clipper;
|
|
static QUAD_TRIANGLES: number[];
|
|
static VERTEX_SIZE: number;
|
|
private vertices;
|
|
private tempColor;
|
|
private materialCustomizer;
|
|
constructor(skeletonData: SkeletonData, materialCustomizer?: SkeletonMeshMaterialParametersCustomizer);
|
|
update(deltaTime: number): void;
|
|
dispose(): void;
|
|
private clearBatches;
|
|
private nextBatch;
|
|
private updateGeometry;
|
|
}
|
|
}
|
|
declare module spine.threejs {
|
|
class ThreeJsTexture extends Texture {
|
|
texture: THREE.Texture;
|
|
constructor(image: HTMLImageElement);
|
|
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
|
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
|
dispose(): void;
|
|
static toThreeJsTextureFilter(filter: TextureFilter): THREE.TextureFilter;
|
|
static toThreeJsTextureWrap(wrap: TextureWrap): THREE.Wrapping;
|
|
}
|
|
}
|
|
declare module spine {
|
|
interface SpinePlayerConfig {
|
|
jsonUrl: string;
|
|
jsonField: string;
|
|
skelUrl: string;
|
|
atlasUrl: string;
|
|
rawDataURIs: Map<string>;
|
|
animation: string;
|
|
animations: string[];
|
|
defaultMix: number;
|
|
skin: string;
|
|
skins: string[];
|
|
premultipliedAlpha: boolean;
|
|
showControls: boolean;
|
|
showLoading: boolean;
|
|
debug: {
|
|
bones: boolean;
|
|
regions: boolean;
|
|
meshes: boolean;
|
|
bounds: boolean;
|
|
paths: boolean;
|
|
clipping: boolean;
|
|
points: boolean;
|
|
hulls: boolean;
|
|
};
|
|
viewport: {
|
|
x: number;
|
|
y: number;
|
|
width: number;
|
|
height: number;
|
|
padLeft: string | number;
|
|
padRight: string | number;
|
|
padTop: string | number;
|
|
padBottom: string | number;
|
|
animations: Map<Viewport>;
|
|
debugRender: boolean;
|
|
transitionTime: number;
|
|
};
|
|
alpha: boolean;
|
|
backgroundColor: string;
|
|
fullScreenBackgroundColor: string;
|
|
backgroundImage: {
|
|
url: string;
|
|
x: number;
|
|
y: number;
|
|
width: number;
|
|
height: number;
|
|
};
|
|
controlBones: string[];
|
|
success: (widget: SpinePlayer) => void;
|
|
error: (widget: SpinePlayer, msg: string) => void;
|
|
downloader: spine.Downloader;
|
|
}
|
|
interface Viewport {
|
|
x: number;
|
|
y: number;
|
|
width: number;
|
|
height: number;
|
|
padLeft: string | number;
|
|
padRight: string | number;
|
|
padTop: string | number;
|
|
padBottom: string | number;
|
|
}
|
|
class SpinePlayer {
|
|
private config;
|
|
private parent;
|
|
private dom;
|
|
private canvas;
|
|
private context;
|
|
private sceneRenderer;
|
|
private loadingScreen;
|
|
private assetManager;
|
|
private bg;
|
|
private bgFullscreen;
|
|
private playerControls;
|
|
private timelineSlider;
|
|
private playButton;
|
|
private skinButton;
|
|
private animationButton;
|
|
private selectedBones;
|
|
private cancelId;
|
|
private lastPopup;
|
|
error: boolean;
|
|
skeleton: Skeleton;
|
|
animationState: AnimationState;
|
|
private paused;
|
|
private playTime;
|
|
private speed;
|
|
private time;
|
|
private stopRequestAnimationFrame;
|
|
private currentViewport;
|
|
private previousViewport;
|
|
private viewportTransitionStart;
|
|
constructor(parent: HTMLElement | string, config: SpinePlayerConfig);
|
|
private validateConfig;
|
|
private showError;
|
|
private render;
|
|
private showSpeedDialog;
|
|
private showAnimationsDialog;
|
|
private showSkinsDialog;
|
|
private showSettingsDialog;
|
|
private drawFrame;
|
|
private scale;
|
|
private loadSkeleton;
|
|
private setupInput;
|
|
private play;
|
|
private pause;
|
|
setAnimation(animation: string, loop?: boolean): void;
|
|
private percentageToWorldUnit;
|
|
private calculateAnimationViewport;
|
|
stopRendering(): void;
|
|
}
|
|
}
|
|
declare function CodeMirror(el: Element, config: any): void;
|
|
declare module spine {
|
|
class SpinePlayerEditor {
|
|
private static DEFAULT_CODE;
|
|
private prefix;
|
|
private postfix;
|
|
private code;
|
|
private player;
|
|
constructor(parent: HTMLElement);
|
|
private render;
|
|
setPreAndPostfix(prefix: string, postfix: string): void;
|
|
setCode(code: string): void;
|
|
private timerId;
|
|
startPlayer(): void;
|
|
}
|
|
}
|