UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-02-04 14:24:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

[ts] Formatter pass

Browse Source
This commit is contained in:
Mario Zechner 2021-08-27 17:24:18 +02:00
parent ef6f2efb1a
commit 39df4c7cbb
66 changed files with 711 additions and 711 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
formatters/README.md
View File

@ -4,7 +4,7 @@ This folder contains formatter configuration files to be used with IDEs as well
You will need the following on your `PATH`:
- JDK 10+
- clang-format 12 (i.e. `brew install clang-format`)
- clang-format 12 (i.e. `brew install clang-format`). Also set the environment variable `CLANGFORMAT` to the path of the `clang-format` executable.
- dotnet format (i.e. `dotnet tool install -g dotnet-format`, comes with dotnet 6 out of the box)
- tsfmt, (i.e. `npm install -g typescript-formatter`)

2
spine-ts/spine-canvas/src/AssetManager.ts
View File

@ -31,7 +31,7 @@ import { AssetManagerBase, Downloader } from "@esotericsoftware/spine-core"
import { CanvasTexture } from "./CanvasTexture";
export class AssetManager extends AssetManagerBase {
constructor(pathPrefix: string = "", downloader: Downloader = null) {
constructor (pathPrefix: string = "", downloader: Downloader = null) {
super((image: HTMLImageElement) => { return new CanvasTexture(image); }, pathPrefix, downloader);
}
}

8
spine-ts/spine-canvas/src/CanvasTexture.ts
View File

@ -30,11 +30,11 @@
import { Texture, TextureFilter, TextureWrap } from "@esotericsoftware/spine-core";
export class CanvasTexture extends Texture {
constructor(image: HTMLImageElement) {
constructor (image: HTMLImageElement) {
super(image);
}
setFilters(minFilter: TextureFilter, magFilter: TextureFilter) { }
setWraps(uWrap: TextureWrap, vWrap: TextureWrap) { }
dispose() { }
setFilters (minFilter: TextureFilter, magFilter: TextureFilter) { }
setWraps (uWrap: TextureWrap, vWrap: TextureWrap) { }
dispose () { }
}

14
spine-ts/spine-canvas/src/SkeletonRenderer.ts
View File

@ -41,16 +41,16 @@ export class SkeletonRenderer {
private vertices = Utils.newFloatArray(8 * 1024);
private tempColor = new Color();
constructor(context: CanvasRenderingContext2D) {
constructor (context: CanvasRenderingContext2D) {
this.ctx = context;
}
draw(skeleton: Skeleton) {
draw (skeleton: Skeleton) {
if (this.triangleRendering) this.drawTriangles(skeleton);
else this.drawImages(skeleton);
}
private drawImages(skeleton: Skeleton) {
private drawImages (skeleton: Skeleton) {
let ctx = this.ctx;
let color = this.tempColor;
let skeletonColor = skeleton.color;
@ -107,7 +107,7 @@ export class SkeletonRenderer {
}
}
private drawTriangles(skeleton: Skeleton) {
private drawTriangles (skeleton: Skeleton) {
let ctx = this.ctx;
let color = this.tempColor;
let skeletonColor = skeleton.color;
@ -182,7 +182,7 @@ export class SkeletonRenderer {
// Adapted from http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
// Apache 2 licensed
private drawTriangle(img: HTMLImageElement, x0: number, y0: number, u0: number, v0: number,
private drawTriangle (img: HTMLImageElement, x0: number, y0: number, u0: number, v0: number,
x1: number, y1: number, u1: number, v1: number,
x2: number, y2: number, u2: number, v2: number) {
let ctx = this.ctx;
@ -229,7 +229,7 @@ export class SkeletonRenderer {
ctx.restore();
}
private computeRegionVertices(slot: Slot, region: RegionAttachment, pma: boolean) {
private computeRegionVertices (slot: Slot, region: RegionAttachment, pma: boolean) {
let skeletonColor = slot.bone.skeleton.color;
let slotColor = slot.color;
let regionColor = region.color;
@ -277,7 +277,7 @@ export class SkeletonRenderer {
return vertices;
}
private computeMeshVertices(slot: Slot, mesh: MeshAttachment, pma: boolean) {
private computeMeshVertices (slot: Slot, mesh: MeshAttachment, pma: boolean) {
let skeletonColor = slot.bone.skeleton.color;
let slotColor = slot.color;
let regionColor = mesh.color;

196
spine-ts/spine-core/src/Animation.ts
View File

@ -46,14 +46,14 @@ export class Animation {
/** The duration of the animation in seconds, which is the highest time of all keys in the timeline. */
duration: number;
constructor(name: string, timelines: Array<Timeline>, duration: number) {
constructor (name: string, timelines: Array<Timeline>, duration: number) {
if (!name) throw new Error("name cannot be null.");
this.name = name;
this.setTimelines(timelines);
this.duration = duration;
}
setTimelines(timelines: Array<Timeline>) {
setTimelines (timelines: Array<Timeline>) {
if (!timelines) throw new Error("timelines cannot be null.");
this.timelines = timelines;
this.timelineIds = new StringSet();
@ -61,7 +61,7 @@ export class Animation {
this.timelineIds.addAll(timelines[i].getPropertyIds());
}
hasTimeline(ids: string[]): boolean {
hasTimeline (ids: string[]): boolean {
for (let i = 0; i < ids.length; i++)
if (this.timelineIds.contains(ids[i])) return true;
return false;
@ -72,7 +72,7 @@ export class Animation {
* See Timeline {@link Timeline#apply(Skeleton, float, float, Array, float, MixBlend, MixDirection)}.
* @param loop If true, the animation repeats after {@link #getDuration()}.
* @param events May be null to ignore fired events. */
apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
if (!skeleton) throw new Error("skeleton cannot be null.");
if (loop && this.duration != 0) {
@ -154,37 +154,37 @@ export abstract class Timeline {
propertyIds: string[];
frames: NumberArrayLike;
constructor(frameCount: number, propertyIds: string[]) {
constructor (frameCount: number, propertyIds: string[]) {
this.propertyIds = propertyIds;
this.frames = Utils.newFloatArray(frameCount * this.getFrameEntries());
}
getPropertyIds() {
getPropertyIds () {
return this.propertyIds;
}
getFrameEntries(): number {
getFrameEntries (): number {
return 1;
}
getFrameCount() {
getFrameCount () {
return this.frames.length / this.getFrameEntries();
}
getDuration(): number {
getDuration (): number {
return this.frames[this.frames.length - this.getFrameEntries()];
}
abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
abstract apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
static search1(frames: NumberArrayLike, time: number) {
static search1 (frames: NumberArrayLike, time: number) {
let n = frames.length;
for (let i = 1; i < n; i++)
if (frames[i] > time) return i - 1;
return n - 1;
}
static search(frames: NumberArrayLike, time: number, step: number) {
static search (frames: NumberArrayLike, time: number, step: number) {
let n = frames.length;
for (let i = step; i < n; i += step)
if (frames[i] > time) return i - step;
@ -206,25 +206,25 @@ export interface SlotTimeline {
export abstract class CurveTimeline extends Timeline {
protected curves: NumberArrayLike; // type, x, y, ...
constructor(frameCount: number, bezierCount: number, propertyIds: string[]) {
constructor (frameCount: number, bezierCount: number, propertyIds: string[]) {
super(frameCount, propertyIds);
this.curves = Utils.newFloatArray(frameCount + bezierCount * 18/*BEZIER_SIZE*/);
this.curves[frameCount - 1] = 1/*STEPPED*/;
}
/** Sets the specified key frame to linear interpolation. */
setLinear(frame: number) {
setLinear (frame: number) {
this.curves[frame] = 0/*LINEAR*/;
}
/** Sets the specified key frame to stepped interpolation. */
setStepped(frame: number) {
setStepped (frame: number) {
this.curves[frame] = 1/*STEPPED*/;
}
/** Shrinks the storage for Bezier curves, for use when <code>bezierCount</code> (specified in the constructor) was larger
* than the actual number of Bezier curves. */
shrink(bezierCount: number) {
shrink (bezierCount: number) {
let size = this.getFrameCount() + bezierCount * 18/*BEZIER_SIZE*/;
if (this.curves.length > size) {
let newCurves = Utils.newFloatArray(size);
@ -247,7 +247,7 @@ export abstract class CurveTimeline extends Timeline {
* @param cy2 The value for the second Bezier handle.
* @param time2 The time for the second key.
* @param value2 The value for the second key. */
setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number,
setBezier (bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number,
cy2: number, time2: number, value2: number) {
let curves = this.curves;
let i = this.getFrameCount() + bezier * 18/*BEZIER_SIZE*/;
@ -273,7 +273,7 @@ export abstract class CurveTimeline extends Timeline {
* @param frameIndex The index into {@link #getFrames()} for the values of the frame before <code>time</code>.
* @param valueOffset The offset from <code>frameIndex</code> to the value this curve is used for.
* @param i The index of the Bezier segments. See {@link #getCurveType(int)}. */
getBezierValue(time: number, frameIndex: number, valueOffset: number, i: number) {
getBezierValue (time: number, frameIndex: number, valueOffset: number, i: number) {
let curves = this.curves;
if (curves[i] > time) {
let x = this.frames[frameIndex], y = this.frames[frameIndex + valueOffset];
@ -293,25 +293,25 @@ export abstract class CurveTimeline extends Timeline {
}
export abstract class CurveTimeline1 extends CurveTimeline {
constructor(frameCount: number, bezierCount: number, propertyId: string) {
constructor (frameCount: number, bezierCount: number, propertyId: string) {
super(frameCount, bezierCount, [propertyId]);
}
getFrameEntries() {
getFrameEntries () {
return 2/*ENTRIES*/;
}
/** Sets the time and value for the specified frame.
* @param frame Between 0 and <code>frameCount</code>, inclusive.
* @param time The frame time in seconds. */
setFrame(frame: number, time: number, value: number) {
setFrame (frame: number, time: number, value: number) {
frame <<= 1;
this.frames[frame] = time;
this.frames[frame + 1/*VALUE*/] = value;
}
/** Returns the interpolated value for the specified time. */
getCurveValue(time: number) {
getCurveValue (time: number) {
let frames = this.frames;
let i = frames.length - 2;
for (let ii = 2; ii <= i; ii += 2) {
@ -337,18 +337,18 @@ export abstract class CurveTimeline1 extends CurveTimeline {
export abstract class CurveTimeline2 extends CurveTimeline {
/** @param bezierCount The maximum number of Bezier curves. See {@link #shrink(int)}.
* @param propertyIds Unique identifiers for the properties the timeline modifies. */
constructor(frameCount: number, bezierCount: number, propertyId1: string, propertyId2: string) {
constructor (frameCount: number, bezierCount: number, propertyId1: string, propertyId2: string) {
super(frameCount, bezierCount, [propertyId1, propertyId2]);
}
getFrameEntries() {
getFrameEntries () {
return 3/*ENTRIES*/;
}
/** Sets the time and values for the specified frame.
* @param frame Between 0 and <code>frameCount</code>, inclusive.
* @param time The frame time in seconds. */
setFrame(frame: number, time: number, value1: number, value2: number) {
setFrame (frame: number, time: number, value1: number, value2: number) {
frame *= 3/*ENTRIES*/;
this.frames[frame] = time;
this.frames[frame + 1/*VALUE1*/] = value1;
@ -360,12 +360,12 @@ export abstract class CurveTimeline2 extends CurveTimeline {
export class RotateTimeline extends CurveTimeline1 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount, Property.rotate + "|" + boneIndex);
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -399,7 +399,7 @@ export class RotateTimeline extends CurveTimeline1 implements BoneTimeline {
export class TranslateTimeline extends CurveTimeline2 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount,
Property.x + "|" + boneIndex,
Property.y + "|" + boneIndex,
@ -407,7 +407,7 @@ export class TranslateTimeline extends CurveTimeline2 implements BoneTimeline {
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -467,12 +467,12 @@ export class TranslateTimeline extends CurveTimeline2 implements BoneTimeline {
export class TranslateXTimeline extends CurveTimeline1 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount, Property.x + "|" + boneIndex);
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -507,12 +507,12 @@ export class TranslateXTimeline extends CurveTimeline1 implements BoneTimeline {
export class TranslateYTimeline extends CurveTimeline1 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount, Property.y + "|" + boneIndex);
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -547,7 +547,7 @@ export class TranslateYTimeline extends CurveTimeline1 implements BoneTimeline {
export class ScaleTimeline extends CurveTimeline2 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount,
Property.scaleX + "|" + boneIndex,
Property.scaleY + "|" + boneIndex
@ -555,7 +555,7 @@ export class ScaleTimeline extends CurveTimeline2 implements BoneTimeline {
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -657,12 +657,12 @@ export class ScaleTimeline extends CurveTimeline2 implements BoneTimeline {
export class ScaleXTimeline extends CurveTimeline1 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount, Property.scaleX + "|" + boneIndex);
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -726,12 +726,12 @@ export class ScaleXTimeline extends CurveTimeline1 implements BoneTimeline {
export class ScaleYTimeline extends CurveTimeline1 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount, Property.scaleY + "|" + boneIndex);
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -795,7 +795,7 @@ export class ScaleYTimeline extends CurveTimeline1 implements BoneTimeline {
export class ShearTimeline extends CurveTimeline2 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount,
Property.shearX + "|" + boneIndex,
Property.shearY + "|" + boneIndex
@ -803,7 +803,7 @@ export class ShearTimeline extends CurveTimeline2 implements BoneTimeline {
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -863,12 +863,12 @@ export class ShearTimeline extends CurveTimeline2 implements BoneTimeline {
export class ShearXTimeline extends CurveTimeline1 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount, Property.shearX + "|" + boneIndex);
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -903,12 +903,12 @@ export class ShearXTimeline extends CurveTimeline1 implements BoneTimeline {
export class ShearYTimeline extends CurveTimeline1 implements BoneTimeline {
boneIndex = 0;
constructor(frameCount: number, bezierCount: number, boneIndex: number) {
constructor (frameCount: number, bezierCount: number, boneIndex: number) {
super(frameCount, bezierCount, Property.shearY + "|" + boneIndex);
this.boneIndex = boneIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active) return;
@ -943,7 +943,7 @@ export class ShearYTimeline extends CurveTimeline1 implements BoneTimeline {
export class RGBATimeline extends CurveTimeline implements SlotTimeline {
slotIndex = 0;
constructor(frameCount: number, bezierCount: number, slotIndex: number) {
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
super(frameCount, bezierCount, [
Property.rgb + "|" + slotIndex,
Property.alpha + "|" + slotIndex
@ -951,12 +951,12 @@ export class RGBATimeline extends CurveTimeline implements SlotTimeline {
this.slotIndex = slotIndex;
}
getFrameEntries() {
getFrameEntries () {
return 5/*ENTRIES*/;
}
/** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */
setFrame(frame: number, time: number, r: number, g: number, b: number, a: number) {
setFrame (frame: number, time: number, r: number, g: number, b: number, a: number) {
frame *= 5/*ENTRIES*/;
this.frames[frame] = time;
this.frames[frame + 1/*R*/] = r;
@ -965,7 +965,7 @@ export class RGBATimeline extends CurveTimeline implements SlotTimeline {
this.frames[frame + 4/*A*/] = a;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let slot = skeleton.slots[this.slotIndex];
if (!slot.bone.active) return;
@ -1025,19 +1025,19 @@ export class RGBATimeline extends CurveTimeline implements SlotTimeline {
export class RGBTimeline extends CurveTimeline implements SlotTimeline {
slotIndex = 0;
constructor(frameCount: number, bezierCount: number, slotIndex: number) {
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
super(frameCount, bezierCount, [
Property.rgb + "|" + slotIndex
]);
this.slotIndex = slotIndex;
}
getFrameEntries() {
getFrameEntries () {
return 4/*ENTRIES*/;
}
/** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */
setFrame(frame: number, time: number, r: number, g: number, b: number) {
setFrame (frame: number, time: number, r: number, g: number, b: number) {
frame <<= 2;
this.frames[frame] = time;
this.frames[frame + 1/*R*/] = r;
@ -1045,7 +1045,7 @@ export class RGBTimeline extends CurveTimeline implements SlotTimeline {
this.frames[frame + 3/*B*/] = b;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let slot = skeleton.slots[this.slotIndex];
if (!slot.bone.active) return;
@ -1113,12 +1113,12 @@ export class RGBTimeline extends CurveTimeline implements SlotTimeline {
export class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
slotIndex = 0;
constructor(frameCount: number, bezierCount: number, slotIndex: number) {
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
super(frameCount, bezierCount, Property.alpha + "|" + slotIndex);
this.slotIndex = slotIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let slot = skeleton.slots[this.slotIndex];
if (!slot.bone.active) return;
@ -1149,7 +1149,7 @@ export class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
export class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
slotIndex = 0;
constructor(frameCount: number, bezierCount: number, slotIndex: number) {
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
super(frameCount, bezierCount, [
Property.rgb + "|" + slotIndex,
Property.alpha + "|" + slotIndex,
@ -1158,12 +1158,12 @@ export class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
this.slotIndex = slotIndex;
}
getFrameEntries() {
getFrameEntries () {
return 8/*ENTRIES*/;
}
/** Sets the time in seconds, light, and dark colors for the specified key frame. */
setFrame(frame: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number) {
setFrame (frame: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number) {
frame <<= 3;
this.frames[frame] = time;
this.frames[frame + 1/*R*/] = r;
@ -1175,7 +1175,7 @@ export class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
this.frames[frame + 7/*B2*/] = b2;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let slot = skeleton.slots[this.slotIndex];
if (!slot.bone.active) return;
@ -1266,7 +1266,7 @@ export class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
export class RGB2Timeline extends CurveTimeline implements SlotTimeline {
slotIndex = 0;
constructor(frameCount: number, bezierCount: number, slotIndex: number) {
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
super(frameCount, bezierCount, [
Property.rgb + "|" + slotIndex,
Property.rgb2 + "|" + slotIndex
@ -1274,12 +1274,12 @@ export class RGB2Timeline extends CurveTimeline implements SlotTimeline {
this.slotIndex = slotIndex;
}
getFrameEntries() {
getFrameEntries () {
return 7/*ENTRIES*/;
}
/** Sets the time in seconds, light, and dark colors for the specified key frame. */
setFrame(frame: number, time: number, r: number, g: number, b: number, r2: number, g2: number, b2: number) {
setFrame (frame: number, time: number, r: number, g: number, b: number, r2: number, g2: number, b2: number) {
frame *= 7/*ENTRIES*/;
this.frames[frame] = time;
this.frames[frame + 1/*R*/] = r;
@ -1290,7 +1290,7 @@ export class RGB2Timeline extends CurveTimeline implements SlotTimeline {
this.frames[frame + 6/*B2*/] = b2;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let slot = skeleton.slots[this.slotIndex];
if (!slot.bone.active) return;
@ -1389,7 +1389,7 @@ export class AttachmentTimeline extends Timeline implements SlotTimeline {
/** The attachment name for each key frame. May contain null values to clear the attachment. */
attachmentNames: Array<string>;
constructor(frameCount: number, slotIndex: number) {
constructor (frameCount: number, slotIndex: number) {
super(frameCount, [
Property.attachment + "|" + slotIndex
]);
@ -1397,17 +1397,17 @@ export class AttachmentTimeline extends Timeline implements SlotTimeline {
this.attachmentNames = new Array<string>(frameCount);
}
getFrameCount() {
getFrameCount () {
return this.frames.length;
}
/** Sets the time in seconds and the attachment name for the specified key frame. */
setFrame(frame: number, time: number, attachmentName: string) {
setFrame (frame: number, time: number, attachmentName: string) {
this.frames[frame] = time;
this.attachmentNames[frame] = attachmentName;
}
apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let slot = skeleton.slots[this.slotIndex];
if (!slot.bone.active) return;
@ -1424,7 +1424,7 @@ export class AttachmentTimeline extends Timeline implements SlotTimeline {
this.setAttachment(skeleton, slot, this.attachmentNames[Timeline.search1(this.frames, time)]);
}
setAttachment(skeleton: Skeleton, slot: Slot, attachmentName: string) {
setAttachment (skeleton: Skeleton, slot: Slot, attachmentName: string) {
slot.setAttachment(!attachmentName ? null : skeleton.getAttachment(this.slotIndex, attachmentName));
}
}
@ -1439,7 +1439,7 @@ export class DeformTimeline extends CurveTimeline implements SlotTimeline {
/** The vertices for each key frame. */
vertices: Array<NumberArrayLike>;
constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment) {
constructor (frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment) {
super(frameCount, bezierCount, [
Property.deform + "|" + slotIndex + "|" + attachment.id
]);
@ -1448,20 +1448,20 @@ export class DeformTimeline extends CurveTimeline implements SlotTimeline {
this.vertices = new Array<NumberArrayLike>(frameCount);
}
getFrameCount() {
getFrameCount () {
return this.frames.length;
}
/** Sets the time in seconds and the vertices for the specified key frame.
* @param vertices Vertex positions for an unweighted VertexAttachment, or deform offsets if it has weights. */
setFrame(frame: number, time: number, vertices: NumberArrayLike) {
setFrame (frame: number, time: number, vertices: NumberArrayLike) {
this.frames[frame] = time;
this.vertices[frame] = vertices;
}
/** @param value1 Ignored (0 is used for a deform timeline).
* @param value2 Ignored (1 is used for a deform timeline). */
setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number,
setBezier (bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number,
cy2: number, time2: number, value2: number) {
let curves = this.curves;
let i = this.getFrameCount() + bezier * 18/*BEZIER_SIZE*/;
@ -1483,7 +1483,7 @@ export class DeformTimeline extends CurveTimeline implements SlotTimeline {
}
}
getCurvePercent(time: number, frame: number) {
getCurvePercent (time: number, frame: number) {
let curves = this.curves;
let i = curves[frame];
switch (i) {
@ -1509,7 +1509,7 @@ export class DeformTimeline extends CurveTimeline implements SlotTimeline {
return y + (1 - y) * (time - x) / (this.frames[frame + this.getFrameEntries()] - x);
}
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let slot: Slot = skeleton.slots[this.slotIndex];
if (!slot.bone.active) return;
let slotAttachment: Attachment = slot.getAttachment();
@ -1691,24 +1691,24 @@ export class EventTimeline extends Timeline {
/** The event for each key frame. */
events: Array<Event>;
constructor(frameCount: number) {
constructor (frameCount: number) {
super(frameCount, EventTimeline.propertyIds);
this.events = new Array<Event>(frameCount);
}
getFrameCount() {
getFrameCount () {
return this.frames.length;
}
/** Sets the time in seconds and the event for the specified key frame. */
setFrame(frame: number, event: Event) {
setFrame (frame: number, event: Event) {
this.frames[frame] = event.time;
this.events[frame] = event;
}
/** Fires events for frames > `lastTime` and <= `time`. */
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
if (!firedEvents) return;
let frames = this.frames;
@ -1744,24 +1744,24 @@ export class DrawOrderTimeline extends Timeline {
/** The draw order for each key frame. See {@link #setFrame(int, float, int[])}. */
drawOrders: Array<Array<number>>;
constructor(frameCount: number) {
constructor (frameCount: number) {
super(frameCount, DrawOrderTimeline.propertyIds);
this.drawOrders = new Array<Array<number>>(frameCount);
}
getFrameCount() {
getFrameCount () {
return this.frames.length;
}
/** Sets the time in seconds and the draw order for the specified key frame.
* @param drawOrder For each slot in {@link Skeleton#slots}, the index of the new draw order. May be null to use setup pose
* draw order. */
setFrame(frame: number, time: number, drawOrder: Array<number>) {
setFrame (frame: number, time: number, drawOrder: Array<number>) {
this.frames[frame] = time;
this.drawOrders[frame] = drawOrder;
}
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
if (direction == MixDirection.mixOut) {
if (blend == MixBlend.setup) Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
return;
@ -1790,19 +1790,19 @@ export class IkConstraintTimeline extends CurveTimeline {
/** The index of the IK constraint slot in {@link Skeleton#ikConstraints} that will be changed. */
ikConstraintIndex: number;
constructor(frameCount: number, bezierCount: number, ikConstraintIndex: number) {
constructor (frameCount: number, bezierCount: number, ikConstraintIndex: number) {
super(frameCount, bezierCount, [
Property.ikConstraint + "|" + ikConstraintIndex
]);
this.ikConstraintIndex = ikConstraintIndex;
}
getFrameEntries() {
getFrameEntries () {
return 6/*ENTRIES*/;
}
/** Sets the time in seconds, mix, softness, bend direction, compress, and stretch for the specified key frame. */
setFrame(frame: number, time: number, mix: number, softness: number, bendDirection: number, compress: boolean, stretch: boolean) {
setFrame (frame: number, time: number, mix: number, softness: number, bendDirection: number, compress: boolean, stretch: boolean) {
frame *= 6/*ENTRIES*/;
this.frames[frame] = time;
this.frames[frame + 1/*MIX*/] = mix;
@ -1812,7 +1812,7 @@ export class IkConstraintTimeline extends CurveTimeline {
this.frames[frame + 5/*STRETCH*/] = stretch ? 1 : 0;
}
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let constraint: IkConstraint = skeleton.ikConstraints[this.ikConstraintIndex];
if (!constraint.active) return;
@ -1888,19 +1888,19 @@ export class TransformConstraintTimeline extends CurveTimeline {
/** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */
transformConstraintIndex: number;
constructor(frameCount: number, bezierCount: number, transformConstraintIndex: number) {
constructor (frameCount: number, bezierCount: number, transformConstraintIndex: number) {
super(frameCount, bezierCount, [
Property.transformConstraint + "|" + transformConstraintIndex
]);
this.transformConstraintIndex = transformConstraintIndex;
}
getFrameEntries() {
getFrameEntries () {
return 7/*ENTRIES*/;
}
/** The time in seconds, rotate mix, translate mix, scale mix, and shear mix for the specified key frame. */
setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number, mixScaleX: number, mixScaleY: number,
setFrame (frame: number, time: number, mixRotate: number, mixX: number, mixY: number, mixScaleX: number, mixScaleY: number,
mixShearY: number) {
let frames = this.frames;
frame *= 7/*ENTRIES*/;
@ -1913,7 +1913,7 @@ export class TransformConstraintTimeline extends CurveTimeline {
frames[frame + 6/*SHEARY*/] = mixShearY;
}
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let constraint: TransformConstraint = skeleton.transformConstraints[this.transformConstraintIndex];
if (!constraint.active) return;
@ -2001,12 +2001,12 @@ export class PathConstraintPositionTimeline extends CurveTimeline1 {
/** The index of the path constraint slot in {@link Skeleton#pathConstraints} that will be changed. */
pathConstraintIndex: number;
constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number) {
constructor (frameCount: number, bezierCount: number, pathConstraintIndex: number) {
super(frameCount, bezierCount, Property.pathConstraintPosition + "|" + pathConstraintIndex);
this.pathConstraintIndex = pathConstraintIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];
if (!constraint.active) return;
@ -2036,12 +2036,12 @@ export class PathConstraintSpacingTimeline extends CurveTimeline1 {
/** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
pathConstraintIndex = 0;
constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number) {
constructor (frameCount: number, bezierCount: number, pathConstraintIndex: number) {
super(frameCount, bezierCount, Property.pathConstraintSpacing + "|" + pathConstraintIndex);
this.pathConstraintIndex = pathConstraintIndex;
}
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];
if (!constraint.active) return;
@ -2072,18 +2072,18 @@ export class PathConstraintMixTimeline extends CurveTimeline {
/** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
pathConstraintIndex = 0;
constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number) {
constructor (frameCount: number, bezierCount: number, pathConstraintIndex: number) {
super(frameCount, bezierCount, [
Property.pathConstraintMix + "|" + pathConstraintIndex
]);
this.pathConstraintIndex = pathConstraintIndex;
}
getFrameEntries() {
getFrameEntries () {
return 4/*ENTRIES*/;
}
setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number) {
setFrame (frame: number, time: number, mixRotate: number, mixX: number, mixY: number) {
let frames = this.frames;
frame <<= 2;
frames[frame] = time;
@ -2092,7 +2092,7 @@ export class PathConstraintMixTimeline extends CurveTimeline {
frames[frame + 3/*Y*/] = mixY;
}
apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];
if (!constraint.active) return;

114
spine-ts/spine-core/src/AnimationState.ts
View File

@ -40,7 +40,7 @@ import { Event } from "./Event";
*
* See [Applying Animations](http://esotericsoftware.com/spine-applying-animations/) in the Spine Runtimes Guide. */
export class AnimationState {
private static emptyAnimation(): Animation {
private static emptyAnimation (): Animation {
if (!_emptyAnimation) _emptyAnimation = new Animation("<empty>", [], 0);
return _emptyAnimation;
}
@ -66,12 +66,12 @@ export class AnimationState {
trackEntryPool = new Pool<TrackEntry>(() => new TrackEntry());
constructor(data: AnimationStateData) {
constructor (data: AnimationStateData) {
this.data = data;
}
/** Increments each track entry {@link TrackEntry#trackTime()}, setting queued animations as current if needed. */
update(delta: number) {
update (delta: number) {
delta *= this.timeScale;
let tracks = this.tracks;
for (let i = 0, n = tracks.length; i < n; i++) {
@ -129,7 +129,7 @@ export class AnimationState {
}
/** Returns true when all mixing from entries are complete. */
updateMixingFrom(to: TrackEntry, delta: number): boolean {
updateMixingFrom (to: TrackEntry, delta: number): boolean {
let from = to.mixingFrom;
if (!from) return true;
@ -158,7 +158,7 @@ export class AnimationState {
/** Poses the skeleton using the track entry animations. There are no side effects other than invoking listeners, so the
* animation state can be applied to multiple skeletons to pose them identically.
* @returns True if any animations were applied. */
apply(skeleton: Skeleton): boolean {
apply (skeleton: Skeleton): boolean {
if (!skeleton) throw new Error("skeleton cannot be null.");
if (this.animationsChanged) this._animationsChanged();
@ -244,7 +244,7 @@ export class AnimationState {
return applied;
}
applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend) {
applyMixingFrom (to: TrackEntry, skeleton: Skeleton, blend: MixBlend) {
let from = to.mixingFrom;
if (from.mixingFrom) this.applyMixingFrom(from, skeleton, blend);
@ -333,7 +333,7 @@ export class AnimationState {
return mix;
}
applyAttachmentTimeline(timeline: AttachmentTimeline, skeleton: Skeleton, time: number, blend: MixBlend, attachments: boolean) {
applyAttachmentTimeline (timeline: AttachmentTimeline, skeleton: Skeleton, time: number, blend: MixBlend, attachments: boolean) {
var slot = skeleton.slots[timeline.slotIndex];
if (!slot.bone.active) return;
@ -347,12 +347,12 @@ export class AnimationState {
if (slot.attachmentState <= this.unkeyedState) slot.attachmentState = this.unkeyedState + SETUP;
}
setAttachment(skeleton: Skeleton, slot: Slot, attachmentName: string, attachments: boolean) {
setAttachment (skeleton: Skeleton, slot: Slot, attachmentName: string, attachments: boolean) {
slot.setAttachment(!attachmentName ? null : skeleton.getAttachment(slot.data.index, attachmentName));
if (attachments) slot.attachmentState = this.unkeyedState + CURRENT;
}
applyRotateTimeline(timeline: RotateTimeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend,
applyRotateTimeline (timeline: RotateTimeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend,
timelinesRotation: Array<number>, i: number, firstFrame: boolean) {
if (firstFrame) timelinesRotation[i] = 0;
@ -410,7 +410,7 @@ export class AnimationState {
bone.rotation = r1 + total * alpha;
}
queueEvents(entry: TrackEntry, animationTime: number) {
queueEvents (entry: TrackEntry, animationTime: number) {
let animationStart = entry.animationStart, animationEnd = entry.animationEnd;
let duration = animationEnd - animationStart;
let trackLastWrapped = entry.trackLast % duration;
@ -445,7 +445,7 @@ export class AnimationState {
*
* It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,
* rather than leaving them in their current pose. */
clearTracks() {
clearTracks () {
let oldDrainDisabled = this.queue.drainDisabled;
this.queue.drainDisabled = true;
for (let i = 0, n = this.tracks.length; i < n; i++)
@ -459,7 +459,7 @@ export class AnimationState {
*
* It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,
* rather than leaving them in their current pose. */
clearTrack(trackIndex: number) {
clearTrack (trackIndex: number) {
if (trackIndex >= this.tracks.length) return;
let current = this.tracks[trackIndex];
if (!current) return;
@ -483,7 +483,7 @@ export class AnimationState {
this.queue.drain();
}
setCurrent(index: number, current: TrackEntry, interrupt: boolean) {
setCurrent (index: number, current: TrackEntry, interrupt: boolean) {
let from = this.expandToIndex(index);
this.tracks[index] = current;
current.previous = null;
@ -507,7 +507,7 @@ export class AnimationState {
/** Sets an animation by name.
*
* See {@link #setAnimationWith()}. */
setAnimation(trackIndex: number, animationName: string, loop: boolean = false) {
setAnimation (trackIndex: number, animationName: string, loop: boolean = false) {
let animation = this.data.skeletonData.findAnimation(animationName);
if (!animation) throw new Error("Animation not found: " + animationName);
return this.setAnimationWith(trackIndex, animation, loop);
@ -519,7 +519,7 @@ export class AnimationState {
* duration. In either case {@link TrackEntry#trackEnd} determines when the track is cleared.
* @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept
* after the {@link AnimationStateListener#dispose()} event occurs. */
setAnimationWith(trackIndex: number, animation: Animation, loop: boolean = false) {
setAnimationWith (trackIndex: number, animation: Animation, loop: boolean = false) {
if (!animation) throw new Error("animation cannot be null.");
let interrupt = true;
let current = this.expandToIndex(trackIndex);
@ -544,7 +544,7 @@ export class AnimationState {
/** Queues an animation by name.
*
* See {@link #addAnimationWith()}. */
addAnimation(trackIndex: number, animationName: string, loop: boolean = false, delay: number = 0) {
addAnimation (trackIndex: number, animationName: string, loop: boolean = false, delay: number = 0) {
let animation = this.data.skeletonData.findAnimation(animationName);
if (!animation) throw new Error("Animation not found: " + animationName);
return this.addAnimationWith(trackIndex, animation, loop, delay);
@ -558,7 +558,7 @@ export class AnimationState {
* previous entry is looping, its next loop completion is used instead of its duration.
* @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept
* after the {@link AnimationStateListener#dispose()} event occurs. */
addAnimationWith(trackIndex: number, animation: Animation, loop: boolean = false, delay: number = 0) {
addAnimationWith (trackIndex: number, animation: Animation, loop: boolean = false, delay: number = 0) {
if (!animation) throw new Error("animation cannot be null.");
let last = this.expandToIndex(trackIndex);
@ -596,7 +596,7 @@ export class AnimationState {
* {@link TrackEntry#setMixDuration()}. Mixing from an empty animation causes the new animation to be applied more and
* more over the mix duration. Properties keyed in the new animation transition from the value from lower tracks or from the
* setup pose value if no lower tracks key the property to the value keyed in the new animation. */
setEmptyAnimation(trackIndex: number, mixDuration: number = 0) {
setEmptyAnimation (trackIndex: number, mixDuration: number = 0) {
let entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation(), false);
entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration;
@ -614,7 +614,7 @@ export class AnimationState {
* loop completion is used instead of its duration.
* @return A track entry to allow further customization of animation playback. References to the track entry must not be kept
* after the {@link AnimationStateListener#dispose()} event occurs. */
addEmptyAnimation(trackIndex: number, mixDuration: number = 0, delay: number = 0) {
addEmptyAnimation (trackIndex: number, mixDuration: number = 0, delay: number = 0) {
let entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation(), false, delay);
if (delay <= 0) entry.delay += entry.mixDuration - mixDuration;
entry.mixDuration = mixDuration;
@ -624,7 +624,7 @@ export class AnimationState {
/** Sets an empty animation for every track, discarding any queued animations, and mixes to it over the specified mix
* duration. */
setEmptyAnimations(mixDuration: number = 0) {
setEmptyAnimations (mixDuration: number = 0) {
let oldDrainDisabled = this.queue.drainDisabled;
this.queue.drainDisabled = true;
for (let i = 0, n = this.tracks.length; i < n; i++) {
@ -635,7 +635,7 @@ export class AnimationState {
this.queue.drain();
}
expandToIndex(index: number) {
expandToIndex (index: number) {
if (index < this.tracks.length) return this.tracks[index];
Utils.ensureArrayCapacity(this.tracks, index + 1, null);
this.tracks.length = index + 1;
@ -643,7 +643,7 @@ export class AnimationState {
}
/** @param last May be null. */
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry) {
trackEntry (trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry) {
let entry = this.trackEntryPool.obtain();
entry.trackIndex = trackIndex;
entry.animation = animation;
@ -675,7 +675,7 @@ export class AnimationState {
}
/** Removes the {@link TrackEntry#getNext() next entry} and all entries after it for the specified entry. */
clearNext(entry: TrackEntry) {
clearNext (entry: TrackEntry) {
let next = entry.next;
while (next) {
this.queue.dispose(next);
@ -684,7 +684,7 @@ export class AnimationState {
entry.next = null;
}
_animationsChanged() {
_animationsChanged () {
this.animationsChanged = false;
this.propertyIDs.clear();
@ -701,7 +701,7 @@ export class AnimationState {
}
}
computeHold(entry: TrackEntry) {
computeHold (entry: TrackEntry) {
let to = entry.mixingTo;
let timelines = entry.animation.timelines;
let timelinesCount = entry.animation.timelines.length;
@ -742,32 +742,32 @@ export class AnimationState {
}
/** Returns the track entry for the animation currently playing on the track, or null if no animation is currently playing. */
getCurrent(trackIndex: number) {
getCurrent (trackIndex: number) {
if (trackIndex >= this.tracks.length) return null;
return this.tracks[trackIndex];
}
/** Adds a listener to receive events for all track entries. */
addListener(listener: AnimationStateListener) {
addListener (listener: AnimationStateListener) {
if (!listener) throw new Error("listener cannot be null.");
this.listeners.push(listener);
}
/** Removes the listener added with {@link #addListener()}. */
removeListener(listener: AnimationStateListener) {
removeListener (listener: AnimationStateListener) {
let index = this.listeners.indexOf(listener);
if (index >= 0) this.listeners.splice(index, 1);
}
/** Removes all listeners added with {@link #addListener()}. */
clearListeners() {
clearListeners () {
this.listeners.length = 0;
}
/** Discards all listener notifications that have not yet been delivered. This can be useful to call from an
* {@link AnimationStateListener} when it is known that further notifications that may have been already queued for delivery
* are not wanted because new animations are being set. */
clearListenerNotifications() {
clearListenerNotifications () {
this.queue.clear();
}
}
@ -930,7 +930,7 @@ export class TrackEntry {
timelineHoldMix = new Array<TrackEntry>();
timelinesRotation = new Array<number>();
reset() {
reset () {
this.next = null;
this.previous = null;
this.mixingFrom = null;
@ -945,7 +945,7 @@ export class TrackEntry {
/** Uses {@link #trackTime} to compute the `animationTime`, which is between {@link #animationStart}
* and {@link #animationEnd}. When the `trackTime` is 0, the `animationTime` is equal to the
* `animationStart` time. */
getAnimationTime() {
getAnimationTime () {
if (this.loop) {
let duration = this.animationEnd - this.animationStart;
if (duration == 0) return this.animationStart;
@ -954,7 +954,7 @@ export class TrackEntry {
return Math.min(this.trackTime + this.animationStart, this.animationEnd);
}
setAnimationLast(animationLast: number) {
setAnimationLast (animationLast: number) {
this.animationLast = animationLast;
this.nextAnimationLast = animationLast;
}
@ -962,7 +962,7 @@ export class TrackEntry {
/** Returns true if at least one loop has been completed.
*
* See {@link AnimationStateListener#complete()}. */
isComplete() {
isComplete () {
return this.trackTime >= this.animationEnd - this.animationStart;
}
@ -973,11 +973,11 @@ export class TrackEntry {
* the short way or the long way around. The two rotations likely change over time, so which direction is the short or long
* way also changes. If the short way was always chosen, bones would flip to the other side when that direction became the
* long way. TrackEntry chooses the short way the first time it is applied and remembers that direction. */
resetRotationDirections() {
resetRotationDirections () {
this.timelinesRotation.length = 0;
}
getTrackComplete() {
getTrackComplete () {
let duration = this.animationEnd - this.animationStart;
if (duration != 0) {
if (this.loop) return duration * (1 + ((this.trackTime / duration) | 0)); // Completion of next loop.
@ -992,44 +992,44 @@ export class EventQueue {
drainDisabled = false;
animState: AnimationState;
constructor(animState: AnimationState) {
constructor (animState: AnimationState) {
this.animState = animState;
}
start(entry: TrackEntry) {
start (entry: TrackEntry) {
this.objects.push(EventType.start);
this.objects.push(entry);
this.animState.animationsChanged = true;
}
interrupt(entry: TrackEntry) {
interrupt (entry: TrackEntry) {
this.objects.push(EventType.interrupt);
this.objects.push(entry);
}
end(entry: TrackEntry) {
end (entry: TrackEntry) {
this.objects.push(EventType.end);
this.objects.push(entry);
this.animState.animationsChanged = true;
}
dispose(entry: TrackEntry) {
dispose (entry: TrackEntry) {
this.objects.push(EventType.dispose);
this.objects.push(entry);
}
complete(entry: TrackEntry) {
complete (entry: TrackEntry) {
this.objects.push(EventType.complete);
this.objects.push(entry);
}
event(entry: TrackEntry, event: Event) {
event (entry: TrackEntry, event: Event) {
this.objects.push(EventType.event);
this.objects.push(entry);
this.objects.push(event);
}
drain() {
drain () {
if (this.drainDisabled) return;
this.drainDisabled = true;
@ -1079,7 +1079,7 @@ export class EventQueue {
this.drainDisabled = false;
}
clear() {
clear () {
this.objects.length = 0;
}
}
@ -1095,43 +1095,43 @@ export enum EventType {
* {@link AnimationState#addListener()}. */
export interface AnimationStateListener {
/** Invoked when this entry has been set as the current entry. */
start(entry: TrackEntry): void;
start (entry: TrackEntry): void;
/** Invoked when another entry has replaced this entry as the current entry. This entry may continue being applied for
* mixing. */
interrupt(entry: TrackEntry): void;
interrupt (entry: TrackEntry): void;
/** Invoked when this entry is no longer the current entry and will never be applied again. */
end(entry: TrackEntry): void;
end (entry: TrackEntry): void;
/** Invoked when this entry will be disposed. This may occur without the entry ever being set as the current entry.
* References to the entry should not be kept after dispose is called, as it may be destroyed or reused. */
dispose(entry: TrackEntry): void;
dispose (entry: TrackEntry): void;
/** Invoked every time this entry's animation completes a loop. */
complete(entry: TrackEntry): void;
complete (entry: TrackEntry): void;
/** Invoked when this entry's animation triggers an event. */
event(entry: TrackEntry, event: Event): void;
event (entry: TrackEntry, event: Event): void;
}
export abstract class AnimationStateAdapter implements AnimationStateListener {
start(entry: TrackEntry) {
start (entry: TrackEntry) {
}
interrupt(entry: TrackEntry) {
interrupt (entry: TrackEntry) {
}
end(entry: TrackEntry) {
end (entry: TrackEntry) {
}
dispose(entry: TrackEntry) {
dispose (entry: TrackEntry) {
}
complete(entry: TrackEntry) {
complete (entry: TrackEntry) {
}
event(entry: TrackEntry, event: Event) {
event (entry: TrackEntry, event: Event) {
}
}

8
spine-ts/spine-core/src/AnimationStateData.ts
View File

@ -42,7 +42,7 @@ export class AnimationStateData {
/** The mix duration to use when no mix duration has been defined between two animations. */
defaultMix = 0;
constructor(skeletonData: SkeletonData) {
constructor (skeletonData: SkeletonData) {
if (!skeletonData) throw new Error("skeletonData cannot be null.");
this.skeletonData = skeletonData;
}
@ -50,7 +50,7 @@ export class AnimationStateData {
/** Sets a mix duration by animation name.
*
* See {@link #setMixWith()}. */
setMix(fromName: string, toName: string, duration: number) {
setMix (fromName: string, toName: string, duration: number) {
let from = this.skeletonData.findAnimation(fromName);
if (!from) throw new Error("Animation not found: " + fromName);
let to = this.skeletonData.findAnimation(toName);
@ -61,7 +61,7 @@ export class AnimationStateData {
/** Sets the mix duration when changing from the specified animation to the other.
*
* See {@link TrackEntry#mixDuration}. */
setMixWith(from: Animation, to: Animation, duration: number) {
setMixWith (from: Animation, to: Animation, duration: number) {
if (!from) throw new Error("from cannot be null.");
if (!to) throw new Error("to cannot be null.");
let key = from.name + "." + to.name;
@ -70,7 +70,7 @@ export class AnimationStateData {
/** Returns the mix duration to use when changing from the specified animation to the other, or the {@link #defaultMix} if
* no mix duration has been set. */
getMix(from: Animation, to: Animation) {
getMix (from: Animation, to: Animation) {
let key = from.name + "." + to.name;
let value = this.animationToMixTime[key];
return value === undefined ? this.defaultMix : value;

50
spine-ts/spine-core/src/AssetManagerBase.ts
View File

@ -40,36 +40,36 @@ export class AssetManagerBase implements Disposable {
private toLoad = 0;
private loaded = 0;
constructor(textureLoader: (image: HTMLImageElement | ImageBitmap) => Texture, pathPrefix: string = "", downloader: Downloader = null) {
constructor (textureLoader: (image: HTMLImageElement | ImageBitmap) => Texture, pathPrefix: string = "", downloader: Downloader = null) {
this.textureLoader = textureLoader;
this.pathPrefix = pathPrefix;
this.downloader = downloader || new Downloader();
}
private start(path: string): string {
private start (path: string): string {
this.toLoad++;
return this.pathPrefix + path;
}
private success(callback: (path: string, data: any) => void, path: string, asset: any) {
private success (callback: (path: string, data: any) => void, path: string, asset: any) {
this.toLoad--;
this.loaded++;
this.assets[path] = asset;
if (callback) callback(path, asset);
}
private error(callback: (path: string, message: string) => void, path: string, message: string) {
private error (callback: (path: string, message: string) => void, path: string, message: string) {
this.toLoad--;
this.loaded++;
this.errors[path] = message;
if (callback) callback(path, message);
}
setRawDataURI(path: string, data: string) {
setRawDataURI (path: string, data: string) {
this.downloader.rawDataUris[this.pathPrefix + path] = data;
}
loadBinary(path: string,
loadBinary (path: string,
success: (path: string, binary: Uint8Array) => void = null,
error: (path: string, message: string) => void = null) {
path = this.start(path);
@ -81,7 +81,7 @@ export class AssetManagerBase implements Disposable {
});
}
loadText(path: string,
loadText (path: string,
success: (path: string, text: string) => void = null,
error: (path: string, message: string) => void = null) {
path = this.start(path);
@ -93,7 +93,7 @@ export class AssetManagerBase implements Disposable {
});
}
loadJson(path: string,
loadJson (path: string,
success: (path: string, object: object) => void = null,
error: (path: string, message: string) => void = null) {
path = this.start(path);
@ -105,7 +105,7 @@ export class AssetManagerBase implements Disposable {
});
}
loadTexture(path: string,
loadTexture (path: string,
success: (path: string, texture: Texture) => void = null,
error: (path: string, message: string) => void = null) {
path = this.start(path);
@ -136,7 +136,7 @@ export class AssetManagerBase implements Disposable {
}
}
loadTextureAtlas(path: string,
loadTextureAtlas (path: string,
success: (path: string, atlas: TextureAtlas) => void = null,
error: (path: string, message: string) => void = null
) {
@ -170,11 +170,11 @@ export class AssetManagerBase implements Disposable {
});
}
get(path: string) {
get (path: string) {
return this.assets[this.pathPrefix + path];
}
require(path: string) {
require (path: string) {
path = this.pathPrefix + path;
let asset = this.assets[path];
if (asset) return asset;
@ -182,7 +182,7 @@ export class AssetManagerBase implements Disposable {
throw Error("Asset not found: " + path + (error ? "\n" + error : ""));
}
remove(path: string) {
remove (path: string) {
path = this.pathPrefix + path;
let asset = this.assets[path];
if ((<any>asset).dispose) (<any>asset).dispose();
@ -190,7 +190,7 @@ export class AssetManagerBase implements Disposable {
return asset;
}
removeAll() {
removeAll () {
for (let key in this.assets) {
let asset = this.assets[key];
if ((<any>asset).dispose) (<any>asset).dispose();
@ -198,27 +198,27 @@ export class AssetManagerBase implements Disposable {
this.assets = {};
}
isLoadingComplete(): boolean {
isLoadingComplete (): boolean {
return this.toLoad == 0;
}
getToLoad(): number {
getToLoad (): number {
return this.toLoad;
}
getLoaded(): number {
getLoaded (): number {
return this.loaded;
}
dispose() {
dispose () {
this.removeAll();
}
hasErrors() {
hasErrors () {
return Object.keys(this.errors).length > 0;
}
getErrors() {
getErrors () {
return this.errors;
}
}
@ -227,7 +227,7 @@ export class Downloader {
private callbacks: StringMap<Array<Function>> = {};
rawDataUris: StringMap<string> = {};
downloadText(url: string, success: (data: string) => void, error: (status: number, responseText: string) => void) {
downloadText (url: string, success: (data: string) => void, error: (status: number, responseText: string) => void) {
if (this.rawDataUris[url]) url = this.rawDataUris[url];
if (this.start(url, success, error)) return;
let request = new XMLHttpRequest();
@ -241,13 +241,13 @@ export class Downloader {
request.send();
}
downloadJson(url: string, success: (data: object) => void, error: (status: number, responseText: string) => void) {
downloadJson (url: string, success: (data: object) => void, error: (status: number, responseText: string) => void) {
this.downloadText(url, (data: string): void => {
success(JSON.parse(data));
}, error);
}
downloadBinary(url: string, success: (data: Uint8Array) => void, error: (status: number, responseText: string) => void) {
downloadBinary (url: string, success: (data: Uint8Array) => void, error: (status: number, responseText: string) => void) {
if (this.rawDataUris[url]) url = this.rawDataUris[url];
if (this.start(url, success, error)) return;
let request = new XMLHttpRequest();
@ -266,7 +266,7 @@ export class Downloader {
request.send();
}
private start(url: string, success: any, error: any) {
private start (url: string, success: any, error: any) {
let callbacks = this.callbacks[url];
try {
if (callbacks) return true;
@ -276,7 +276,7 @@ export class Downloader {
}
}
private finish(url: string, status: number, data: any) {
private finish (url: string, status: number, data: any) {
let callbacks = this.callbacks[url];
delete this.callbacks[url];
let args = status == 200 ? [data] : [status, data];

14
spine-ts/spine-core/src/AtlasAttachmentLoader.ts
View File

@ -44,11 +44,11 @@ import { TextureAtlas } from "./TextureAtlas";
export class AtlasAttachmentLoader implements AttachmentLoader {
atlas: TextureAtlas;
constructor(atlas: TextureAtlas) {
constructor (atlas: TextureAtlas) {
this.atlas = atlas;
}
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment {
newRegionAttachment (skin: Skin, name: string, path: string): RegionAttachment {
let region = this.atlas.findRegion(path);
if (!region) throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")");
region.renderObject = region;
@ -57,7 +57,7 @@ export class AtlasAttachmentLoader implements AttachmentLoader {
return attachment;
}
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment {
newMeshAttachment (skin: Skin, name: string, path: string): MeshAttachment {
let region = this.atlas.findRegion(path);
if (!region) throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
region.renderObject = region;
@ -66,19 +66,19 @@ export class AtlasAttachmentLoader implements AttachmentLoader {
return attachment;
}
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment {
newBoundingBoxAttachment (skin: Skin, name: string): BoundingBoxAttachment {
return new BoundingBoxAttachment(name);
}
newPathAttachment(skin: Skin, name: string): PathAttachment {
newPathAttachment (skin: Skin, name: string): PathAttachment {
return new PathAttachment(name);
}
newPointAttachment(skin: Skin, name: string): PointAttachment {
newPointAttachment (skin: Skin, name: string): PointAttachment {
return new PointAttachment(name);
}
newClippingAttachment(skin: Skin, name: string): ClippingAttachment {
newClippingAttachment (skin: Skin, name: string): ClippingAttachment {
return new ClippingAttachment(name);
}
}

32
spine-ts/spine-core/src/Bone.ts
View File

@ -114,7 +114,7 @@ export class Bone implements Updatable {
active = false;
/** @param parent May be null. */
constructor(data: BoneData, skeleton: Skeleton, parent: Bone) {
constructor (data: BoneData, skeleton: Skeleton, parent: Bone) {
if (!data) throw new Error("data cannot be null.");
if (!skeleton) throw new Error("skeleton cannot be null.");
this.data = data;
@ -125,19 +125,19 @@ export class Bone implements Updatable {
/** Returns false when the bone has not been computed because {@link BoneData#skinRequired} is true and the
* {@link Skeleton#skin active skin} does not {@link Skin#bones contain} this bone. */
isActive() {
isActive () {
return this.active;
}
/** Computes the world transform using the parent bone and this bone's local applied transform. */
update() {
update () {
this.updateWorldTransformWith(this.ax, this.ay, this.arotation, this.ascaleX, this.ascaleY, this.ashearX, this.ashearY);
}
/** Computes the world transform using the parent bone and this bone's local transform.
*
* See {@link #updateWorldTransformWith()}. */
updateWorldTransform() {
updateWorldTransform () {
this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY);
}
@ -146,7 +146,7 @@ export class Bone implements Updatable {
*
* See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
* Runtimes Guide. */
updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number) {
updateWorldTransformWith (x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number) {
this.ax = x;
this.ay = y;
this.arotation = rotation;
@ -256,7 +256,7 @@ export class Bone implements Updatable {
}
/** Sets this bone's local transform to the setup pose. */
setToSetupPose() {
setToSetupPose () {
let data = this.data;
this.x = data.x;
this.y = data.y;
@ -268,22 +268,22 @@ export class Bone implements Updatable {
}
/** The world rotation for the X axis, calculated using {@link #a} and {@link #c}. */
getWorldRotationX() {
getWorldRotationX () {
return Math.atan2(this.c, this.a) * MathUtils.radDeg;
}
/** The world rotation for the Y axis, calculated using {@link #b} and {@link #d}. */
getWorldRotationY() {
getWorldRotationY () {
return Math.atan2(this.d, this.b) * MathUtils.radDeg;
}
/** The magnitude (always positive) of the world scale X, calculated using {@link #a} and {@link #c}. */
getWorldScaleX() {
getWorldScaleX () {
return Math.sqrt(this.a * this.a + this.c * this.c);
}
/** The magnitude (always positive) of the world scale Y, calculated using {@link #b} and {@link #d}. */
getWorldScaleY() {
getWorldScaleY () {
return Math.sqrt(this.b * this.b + this.d * this.d);
}
@ -295,7 +295,7 @@ export class Bone implements Updatable {
*
* Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The applied transform after
* calling this method is equivalent to the local transform used to compute the world transform, but may not be identical. */
updateAppliedTransform() {
updateAppliedTransform () {
let parent = this.parent;
if (!parent) {
this.ax = this.worldX;
@ -336,7 +336,7 @@ export class Bone implements Updatable {
}
/** Transforms a point from world coordinates to the bone's local coordinates. */
worldToLocal(world: Vector2) {
worldToLocal (world: Vector2) {
let invDet = 1 / (this.a * this.d - this.b * this.c);
let x = world.x - this.worldX, y = world.y - this.worldY;
world.x = x * this.d * invDet - y * this.b * invDet;
@ -345,7 +345,7 @@ export class Bone implements Updatable {
}
/** Transforms a point from the bone's local coordinates to world coordinates. */
localToWorld(local: Vector2) {
localToWorld (local: Vector2) {
let x = local.x, y = local.y;
local.x = x * this.a + y * this.b + this.worldX;
local.y = x * this.c + y * this.d + this.worldY;
@ -353,13 +353,13 @@ export class Bone implements Updatable {
}
/** Transforms a world rotation to a local rotation. */
worldToLocalRotation(worldRotation: number) {
worldToLocalRotation (worldRotation: number) {
let sin = MathUtils.sinDeg(worldRotation), cos = MathUtils.cosDeg(worldRotation);
return Math.atan2(this.a * sin - this.c * cos, this.d * cos - this.b * sin) * MathUtils.radDeg + this.rotation - this.shearX;
}
/** Transforms a local rotation to a world rotation. */
localToWorldRotation(localRotation: number) {
localToWorldRotation (localRotation: number) {
localRotation -= this.rotation - this.shearX;
let sin = MathUtils.sinDeg(localRotation), cos = MathUtils.cosDeg(localRotation);
return Math.atan2(cos * this.c + sin * this.d, cos * this.a + sin * this.b) * MathUtils.radDeg;
@ -369,7 +369,7 @@ export class Bone implements Updatable {
* <p>
* After changes are made to the world transform, {@link #updateAppliedTransform()} should be called and {@link #update()} will
* need to be called on any child bones, recursively. */
rotateWorld(degrees: number) {
rotateWorld (degrees: number) {
let a = this.a, b = this.b, c = this.c, d = this.d;
let cos = MathUtils.cosDeg(degrees), sin = MathUtils.sinDeg(degrees);
this.a = cos * a - sin * c;

2
spine-ts/spine-core/src/BoneData.ts
View File

@ -76,7 +76,7 @@ export class BoneData {
* rendered at runtime. */
color = new Color();
constructor(index: number, name: string, parent: BoneData) {
constructor (index: number, name: string, parent: BoneData) {
if (index < 0) throw new Error("index must be >= 0.");
if (!name) throw new Error("name cannot be null.");
this.index = index;

2
spine-ts/spine-core/src/ConstraintData.ts
View File

@ -29,5 +29,5 @@
/** The base class for all constraint datas. */
export abstract class ConstraintData {
constructor(public name: string, public order: number, public skinRequired: boolean) { }
constructor (public name: string, public order: number, public skinRequired: boolean) { }
}

2
spine-ts/spine-core/src/Event.ts
View File

@ -43,7 +43,7 @@ export class Event {
volume: number;
balance: number;
constructor(time: number, data: EventData) {
constructor (time: number, data: EventData) {
if (!data) throw new Error("data cannot be null.");
this.time = time;
this.data = data;

2
spine-ts/spine-core/src/EventData.ts
View File

@ -39,7 +39,7 @@ export class EventData {
volume: number;
balance: number;
constructor(name: string) {
constructor (name: string) {
this.name = name;
}
}

10
spine-ts/spine-core/src/IkConstraint.ts
View File

@ -65,7 +65,7 @@ export class IkConstraint implements Updatable {
softness = 0;
active = false;
constructor(data: IkConstraintData, skeleton: Skeleton) {
constructor (data: IkConstraintData, skeleton: Skeleton) {
if (!data) throw new Error("data cannot be null.");
if (!skeleton) throw new Error("skeleton cannot be null.");
this.data = data;
@ -81,11 +81,11 @@ export class IkConstraint implements Updatable {
this.target = skeleton.findBone(data.target.name);
}
isActive() {
isActive () {
return this.active;
}
update() {
update () {
if (this.mix == 0) return;
let target = this.target;
let bones = this.bones;
@ -100,7 +100,7 @@ export class IkConstraint implements Updatable {
}
/** Applies 1 bone IK. The target is specified in the world coordinate system. */
apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number) {
apply1 (bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number) {
let p = bone.parent;
let pa = p.a, pb = p.b, pc = p.c, pd = p.d;
let rotationIK = -bone.ashearX - bone.arotation, tx = 0, ty = 0;
@ -151,7 +151,7 @@ export class IkConstraint implements Updatable {
/** Applies 2 bone IK. The target is specified in the world coordinate system.
* @param child A direct descendant of the parent bone. */
apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, uniform: boolean, softness: number, alpha: number) {
apply2 (parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, uniform: boolean, softness: number, alpha: number) {
let px = parent.ax, py = parent.ay, psx = parent.ascaleX, psy = parent.ascaleY, sx = psx, sy = psy, csx = child.ascaleX;
let os1 = 0, os2 = 0, s2 = 0;
if (psx < 0) {

2
spine-ts/spine-core/src/IkConstraintData.ts
View File

@ -61,7 +61,7 @@ export class IkConstraintData extends ConstraintData {
/** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
softness = 0;
constructor(name: string) {
constructor (name: string) {
super(name, 0, false);
}
}

14
spine-ts/spine-core/src/PathConstraint.ts
View File

@ -71,7 +71,7 @@ export class PathConstraint implements Updatable {
active = false;
constructor(data: PathConstraintData, skeleton: Skeleton) {
constructor (data: PathConstraintData, skeleton: Skeleton) {
if (!data) throw new Error("data cannot be null.");
if (!skeleton) throw new Error("skeleton cannot be null.");
this.data = data;
@ -86,11 +86,11 @@ export class PathConstraint implements Updatable {
this.mixY = data.mixY;
}
isActive() {
isActive () {
return this.active;
}
update() {
update () {
let attachment = this.target.getAttachment();
if (!(attachment instanceof PathAttachment)) return;
@ -219,7 +219,7 @@ export class PathConstraint implements Updatable {
}
}
computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean) {
computeWorldPositions (path: PathAttachment, spacesCount: number, tangents: boolean) {
let target = this.target;
let position = this.position;
let spaces = this.spaces, out = Utils.setArraySize(this.positions, spacesCount * 3 + 2), world: Array<number> = null;
@ -452,21 +452,21 @@ export class PathConstraint implements Updatable {
return out;
}
addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number) {
addBeforePosition (p: number, temp: Array<number>, i: number, out: Array<number>, o: number) {
let x1 = temp[i], y1 = temp[i + 1], dx = temp[i + 2] - x1, dy = temp[i + 3] - y1, r = Math.atan2(dy, dx);
out[o] = x1 + p * Math.cos(r);
out[o + 1] = y1 + p * Math.sin(r);
out[o + 2] = r;
}
addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number) {
addAfterPosition (p: number, temp: Array<number>, i: number, out: Array<number>, o: number) {
let x1 = temp[i + 2], y1 = temp[i + 3], dx = x1 - temp[i], dy = y1 - temp[i + 1], r = Math.atan2(dy, dx);
out[o] = x1 + p * Math.cos(r);
out[o + 1] = y1 + p * Math.sin(r);
out[o + 2] = r;
}
addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number,
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) {
if (p == 0 || isNaN(p)) {
out[o] = x1;

2
spine-ts/spine-core/src/PathConstraintData.ts
View File

@ -65,7 +65,7 @@ export class PathConstraintData extends ConstraintData {
mixX = 0;
mixY = 0;
constructor(name: string) {
constructor (name: string) {
super(name, 0, false);
}
}

58
spine-ts/spine-core/src/Skeleton.ts
View File

@ -94,7 +94,7 @@ export class Skeleton {
/** Sets the skeleton Y position, which is added to the root bone worldY position. */
y = 0;
constructor(data: SkeletonData) {
constructor (data: SkeletonData) {
if (!data) throw new Error("data cannot be null.");
this.data = data;
@ -146,7 +146,7 @@ export class Skeleton {
/** Caches information about bones and constraints. Must be called if the {@link #getSkin()} is modified or if bones,
* constraints, or weighted path attachments are added or removed. */
updateCache() {
updateCache () {
let updateCache = this._updateCache;
updateCache.length = 0;
@ -205,7 +205,7 @@ export class Skeleton {
this.sortBone(bones[i]);
}
sortIkConstraint(constraint: IkConstraint) {
sortIkConstraint (constraint: IkConstraint) {
constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)));
if (!constraint.active) return;
@ -230,7 +230,7 @@ export class Skeleton {
}
}
sortPathConstraint(constraint: PathConstraint) {
sortPathConstraint (constraint: PathConstraint) {
constraint.active = constraint.target.bone.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)));
if (!constraint.active) return;
@ -259,7 +259,7 @@ export class Skeleton {
constrained[i].sorted = true;
}
sortTransformConstraint(constraint: TransformConstraint) {
sortTransformConstraint (constraint: TransformConstraint) {
constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)));
if (!constraint.active) return;
@ -287,7 +287,7 @@ export class Skeleton {
constrained[i].sorted = true;
}
sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone) {
sortPathConstraintAttachment (skin: Skin, slotIndex: number, slotBone: Bone) {
let attachments = skin.attachments[slotIndex];
if (!attachments) return;
for (let key in attachments) {
@ -295,7 +295,7 @@ export class Skeleton {
}
}
sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone) {
sortPathConstraintAttachmentWith (attachment: Attachment, slotBone: Bone) {
if (!(attachment instanceof PathAttachment)) return;
let pathBones = (<PathAttachment>attachment).bones;
if (!pathBones)
@ -311,7 +311,7 @@ export class Skeleton {
}
}
sortBone(bone: Bone) {
sortBone (bone: Bone) {
if (bone.sorted) return;
let parent = bone.parent;
if (parent) this.sortBone(parent);
@ -319,7 +319,7 @@ export class Skeleton {
this._updateCache.push(bone);
}
sortReset(bones: Array<Bone>) {
sortReset (bones: Array<Bone>) {
for (let i = 0, n = bones.length; i < n; i++) {
let bone = bones[i];
if (!bone.active) continue;
@ -332,7 +332,7 @@ export class Skeleton {
*
* See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
* Runtimes Guide. */
updateWorldTransform() {
updateWorldTransform () {
let bones = this.bones;
for (let i = 0, n = bones.length; i < n; i++) {
let bone = bones[i];
@ -350,7 +350,7 @@ export class Skeleton {
updateCache[i].update();
}
updateWorldTransformWith(parent: Bone) {
updateWorldTransformWith (parent: Bone) {
// Apply the parent bone transform to the root bone. The root bone always inherits scale, rotation and reflection.
let rootBone = this.getRootBone();
let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
@ -376,13 +376,13 @@ export class Skeleton {
}
/** Sets the bones, constraints, and slots to their setup pose values. */
setToSetupPose() {
setToSetupPose () {
this.setBonesToSetupPose();
this.setSlotsToSetupPose();
}
/** Sets the bones and constraints to their setup pose values. */
setBonesToSetupPose() {
setBonesToSetupPose () {
let bones = this.bones;
for (let i = 0, n = bones.length; i < n; i++)
bones[i].setToSetupPose();
@ -422,7 +422,7 @@ export class Skeleton {
}
/** Sets the slots and draw order to their setup pose values. */
setSlotsToSetupPose() {
setSlotsToSetupPose () {
let slots = this.slots;
Utils.arrayCopy(slots, 0, this.drawOrder, 0, slots.length);
for (let i = 0, n = slots.length; i < n; i++)
@ -430,13 +430,13 @@ export class Skeleton {
}
/** @returns May return null. */
getRootBone() {
getRootBone () {
if (this.bones.length == 0) return null;
return this.bones[0];
}
/** @returns May be null. */
findBone(boneName: string) {
findBone (boneName: string) {
if (!boneName) throw new Error("boneName cannot be null.");
let bones = this.bones;
for (let i = 0, n = bones.length; i < n; i++) {
@ -447,7 +447,7 @@ export class Skeleton {
}
/** @returns -1 if the bone was not found. */
findBoneIndex(boneName: string) {
findBoneIndex (boneName: string) {
if (!boneName) throw new Error("boneName cannot be null.");
let bones = this.bones;
for (let i = 0, n = bones.length; i < n; i++)
@ -458,7 +458,7 @@ export class Skeleton {
/** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
* repeatedly.
* @returns May be null. */
findSlot(slotName: string) {
findSlot (slotName: string) {
if (!slotName) throw new Error("slotName cannot be null.");
let slots = this.slots;
for (let i = 0, n = slots.length; i < n; i++) {
@ -469,7 +469,7 @@ export class Skeleton {
}
/** @returns -1 if the bone was not found. */
findSlotIndex(slotName: string) {
findSlotIndex (slotName: string) {
if (!slotName) throw new Error("slotName cannot be null.");
let slots = this.slots;
for (let i = 0, n = slots.length; i < n; i++)
@ -480,7 +480,7 @@ export class Skeleton {
/** Sets a skin by name.
*
* See {@link #setSkin()}. */
setSkinByName(skinName: string) {
setSkinByName (skinName: string) {
let skin = this.data.findSkin(skinName);
if (!skin) throw new Error("Skin not found: " + skinName);
this.setSkin(skin);
@ -496,7 +496,7 @@ export class Skeleton {
* {@link #setSlotsToSetupPose()}. Also, often {@link AnimationState#apply()} is called before the next time the
* skeleton is rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new skin.
* @param newSkin May be null. */
setSkin(newSkin: Skin) {
setSkin (newSkin: Skin) {
if (newSkin == this.skin) return;
if (newSkin) {
if (this.skin)
@ -523,7 +523,7 @@ export class Skeleton {
*
* See {@link #getAttachment()}.
* @returns May be null. */
getAttachmentByName(slotName: string, attachmentName: string): Attachment {
getAttachmentByName (slotName: string, attachmentName: string): Attachment {
return this.getAttachment(this.data.findSlotIndex(slotName), attachmentName);
}
@ -532,7 +532,7 @@ export class Skeleton {
*
* See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.
* @returns May be null. */
getAttachment(slotIndex: number, attachmentName: string): Attachment {
getAttachment (slotIndex: number, attachmentName: string): Attachment {
if (!attachmentName) throw new Error("attachmentName cannot be null.");
if (this.skin) {
let attachment: Attachment = this.skin.getAttachment(slotIndex, attachmentName);
@ -545,7 +545,7 @@ export class Skeleton {
/** A convenience method to set an attachment by finding the slot with {@link #findSlot()}, finding the attachment with
* {@link #getAttachment()}, then setting the slot's {@link Slot#attachment}.
* @param attachmentName May be null to clear the slot's attachment. */
setAttachment(slotName: string, attachmentName: string) {
setAttachment (slotName: string, attachmentName: string) {
if (!slotName) throw new Error("slotName cannot be null.");
let slots = this.slots;
for (let i = 0, n = slots.length; i < n; i++) {
@ -567,7 +567,7 @@ export class Skeleton {
/** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
* than to call it repeatedly.
* @return May be null. */
findIkConstraint(constraintName: string) {
findIkConstraint (constraintName: string) {
if (!constraintName) throw new Error("constraintName cannot be null.");
let ikConstraints = this.ikConstraints;
for (let i = 0, n = ikConstraints.length; i < n; i++) {
@ -580,7 +580,7 @@ export class Skeleton {
/** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of
* this method than to call it repeatedly.
* @return May be null. */
findTransformConstraint(constraintName: string) {
findTransformConstraint (constraintName: string) {
if (!constraintName) throw new Error("constraintName cannot be null.");
let transformConstraints = this.transformConstraints;
for (let i = 0, n = transformConstraints.length; i < n; i++) {
@ -593,7 +593,7 @@ export class Skeleton {
/** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method
* than to call it repeatedly.
* @return May be null. */
findPathConstraint(constraintName: string) {
findPathConstraint (constraintName: string) {
if (!constraintName) throw new Error("constraintName cannot be null.");
let pathConstraints = this.pathConstraints;
for (let i = 0, n = pathConstraints.length; i < n; i++) {
@ -607,7 +607,7 @@ export class Skeleton {
* @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
* @param size An output value, the width and height of the AABB.
* @param temp Working memory to temporarily store attachments' computed world vertices. */
getBounds(offset: Vector2, size: Vector2, temp: Array<number> = new Array<number>(2)) {
getBounds (offset: Vector2, size: Vector2, temp: Array<number> = new Array<number>(2)) {
if (!offset) throw new Error("offset cannot be null.");
if (!size) throw new Error("size cannot be null.");
let drawOrder = this.drawOrder;
@ -643,7 +643,7 @@ export class Skeleton {
}
/** Increments the skeleton's {@link #time}. */
update(delta: number) {
update (delta: number) {
this.time += delta;
}
}

46
spine-ts/spine-core/src/SkeletonBinary.ts
View File

@ -57,11 +57,11 @@ export class SkeletonBinary {
attachmentLoader: AttachmentLoader;
private linkedMeshes = new Array<LinkedMesh>();
constructor(attachmentLoader: AttachmentLoader) {
constructor (attachmentLoader: AttachmentLoader) {
this.attachmentLoader = attachmentLoader;
}
readSkeletonData(binary: Uint8Array): SkeletonData {
readSkeletonData (binary: Uint8Array): SkeletonData {
let scale = this.scale;
let skeletonData = new SkeletonData();
@ -247,7 +247,7 @@ export class SkeletonBinary {
return skeletonData;
}
private readSkin(input: BinaryInput, skeletonData: SkeletonData, defaultSkin: boolean, nonessential: boolean): Skin {
private readSkin (input: BinaryInput, skeletonData: SkeletonData, defaultSkin: boolean, nonessential: boolean): Skin {
let skin = null;
let slotCount = 0;
@ -282,7 +282,7 @@ export class SkeletonBinary {
return skin;
}
private readAttachment(input: BinaryInput, skeletonData: SkeletonData, skin: Skin, slotIndex: number, attachmentName: string, nonessential: boolean): Attachment {
private readAttachment (input: BinaryInput, skeletonData: SkeletonData, skin: Skin, slotIndex: number, attachmentName: string, nonessential: boolean): Attachment {
let scale = this.scale;
let name = input.readStringRef();
@ -441,7 +441,7 @@ export class SkeletonBinary {
return null;
}
private readVertices(input: BinaryInput, vertexCount: number): Vertices {
private readVertices (input: BinaryInput, vertexCount: number): Vertices {
let scale = this.scale;
let verticesLength = vertexCount << 1;
let vertices = new Vertices();
@ -466,7 +466,7 @@ export class SkeletonBinary {
return vertices;
}
private readFloatArray(input: BinaryInput, n: number, scale: number): number[] {
private readFloatArray (input: BinaryInput, n: number, scale: number): number[] {
let array = new Array<number>(n);
if (scale == 1) {
for (let i = 0; i < n; i++)
@ -478,7 +478,7 @@ export class SkeletonBinary {
return array;
}
private readShortArray(input: BinaryInput): number[] {
private readShortArray (input: BinaryInput): number[] {
let n = input.readInt(true);
let array = new Array<number>(n);
for (let i = 0; i < n; i++)
@ -486,7 +486,7 @@ export class SkeletonBinary {
return array;
}
private readAnimation(input: BinaryInput, name: string, skeletonData: SkeletonData): Animation {
private readAnimation (input: BinaryInput, name: string, skeletonData: SkeletonData): Animation {
input.readInt(true); // Number of timelines.
let timelines = new Array<Timeline>();
let scale = this.scale;
@ -960,30 +960,30 @@ export class SkeletonBinary {
}
export class BinaryInput {
constructor(data: Uint8Array, public strings = new Array<string>(), private index: number = 0, private buffer = new DataView(data.buffer)) {
constructor (data: Uint8Array, public strings = new Array<string>(), private index: number = 0, private buffer = new DataView(data.buffer)) {
}
readByte(): number {
readByte (): number {
return this.buffer.getInt8(this.index++);
}
readUnsignedByte(): number {
readUnsignedByte (): number {
return this.buffer.getUint8(this.index++);
}
readShort(): number {
readShort (): number {
let value = this.buffer.getInt16(this.index);
this.index += 2;
return value;
}
readInt32(): number {
readInt32 (): number {
let value = this.buffer.getInt32(this.index)
this.index += 4;
return value;
}
readInt(optimizePositive: boolean) {
readInt (optimizePositive: boolean) {
let b = this.readByte();
let result = b & 0x7F;
if ((b & 0x80) != 0) {
@ -1005,12 +1005,12 @@ export class BinaryInput {
return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));
}
readStringRef(): string {
readStringRef (): string {
let index = this.readInt(true);
return index == 0 ? null : this.strings[index - 1];
}
readString(): string {
readString (): string {
let byteCount = this.readInt(true);
switch (byteCount) {
case 0:
@ -1041,13 +1041,13 @@ export class BinaryInput {
return chars;
}
readFloat(): number {
readFloat (): number {
let value = this.buffer.getFloat32(this.index);
this.index += 4;
return value;
}
readBoolean(): boolean {
readBoolean (): boolean {
return this.readByte() != 0;
}
}
@ -1058,7 +1058,7 @@ class LinkedMesh {
mesh: MeshAttachment;
inheritDeform: boolean;
constructor(mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {
constructor (mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {
this.mesh = mesh;
this.skin = skin;
this.slotIndex = slotIndex;
@ -1068,12 +1068,12 @@ class LinkedMesh {
}
class Vertices {
constructor(public bones: Array<number> = null, public vertices: Array<number> | Float32Array = null) { }
constructor (public bones: Array<number> = null, public vertices: Array<number> | Float32Array = null) { }
}
enum AttachmentType { Region, BoundingBox, Mesh, LinkedMesh, Path, Point, Clipping }
function readTimeline1(input: BinaryInput, timeline: CurveTimeline1, scale: number): CurveTimeline1 {
function readTimeline1 (input: BinaryInput, timeline: CurveTimeline1, scale: number): CurveTimeline1 {
let time = input.readFloat(), value = input.readFloat() * scale;
for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1; ; frame++) {
timeline.setFrame(frame, time, value);
@ -1092,7 +1092,7 @@ function readTimeline1(input: BinaryInput, timeline: CurveTimeline1, scale: numb
return timeline;
}
function readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: number): CurveTimeline2 {
function readTimeline2 (input: BinaryInput, timeline: CurveTimeline2, scale: number): CurveTimeline2 {
let time = input.readFloat(), value1 = input.readFloat() * scale, value2 = input.readFloat() * scale;
for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1; ; frame++) {
timeline.setFrame(frame, time, value1, value2);
@ -1113,7 +1113,7 @@ function readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: numb
return timeline;
}
function setBezier(input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number,
function setBezier (input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number,
time1: number, time2: number, value1: number, value2: number, scale: number) {
timeline.setBezier(bezier, frame, value, time1, value1, input.readFloat(), input.readFloat() * scale, input.readFloat(), input.readFloat() * scale, time2, value2);
}

24
spine-ts/spine-core/src/SkeletonBounds.ts
View File

@ -61,7 +61,7 @@ export class SkeletonBounds {
* box's polygon.
* @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
* SkeletonBounds AABB methods will always return true. */
update(skeleton: Skeleton, updateAabb: boolean) {
update (skeleton: Skeleton, updateAabb: boolean) {
if (!skeleton) throw new Error("skeleton cannot be null.");
let boundingBoxes = this.boundingBoxes;
let polygons = this.polygons;
@ -100,7 +100,7 @@ export class SkeletonBounds {
}
}
aabbCompute() {
aabbCompute () {
let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
let polygons = this.polygons;
for (let i = 0, n = polygons.length; i < n; i++) {
@ -122,12 +122,12 @@ export class SkeletonBounds {
}
/** Returns true if the axis aligned bounding box contains the point. */
aabbContainsPoint(x: number, y: number) {
aabbContainsPoint (x: number, y: number) {
return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;
}
/** Returns true if the axis aligned bounding box intersects the line segment. */
aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number) {
aabbIntersectsSegment (x1: number, y1: number, x2: number, y2: number) {
let minX = this.minX;
let minY = this.minY;
let maxX = this.maxX;
@ -147,13 +147,13 @@ export class SkeletonBounds {
}
/** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
aabbIntersectsSkeleton(bounds: SkeletonBounds) {
aabbIntersectsSkeleton (bounds: SkeletonBounds) {
return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY > bounds.minY;
}
/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
* efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
containsPoint(x: number, y: number): BoundingBoxAttachment {
containsPoint (x: number, y: number): BoundingBoxAttachment {
let polygons = this.polygons;
for (let i = 0, n = polygons.length; i < n; i++)
if (this.containsPointPolygon(polygons[i], x, y)) return this.boundingBoxes[i];
@ -161,7 +161,7 @@ export class SkeletonBounds {
}
/** Returns true if the polygon contains the point. */
containsPointPolygon(polygon: NumberArrayLike, x: number, y: number) {
containsPointPolygon (polygon: NumberArrayLike, x: number, y: number) {
let vertices = polygon;
let nn = polygon.length;
@ -182,7 +182,7 @@ export class SkeletonBounds {
/** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it
* is usually more efficient to only call this method if {@link #aabbIntersectsSegment()} returns
* true. */
intersectsSegment(x1: number, y1: number, x2: number, y2: number) {
intersectsSegment (x1: number, y1: number, x2: number, y2: number) {
let polygons = this.polygons;
for (let i = 0, n = polygons.length; i < n; i++)
if (this.intersectsSegmentPolygon(polygons[i], x1, y1, x2, y2)) return this.boundingBoxes[i];
@ -190,7 +190,7 @@ export class SkeletonBounds {
}
/** Returns true if the polygon contains any part of the line segment. */
intersectsSegmentPolygon(polygon: NumberArrayLike, x1: number, y1: number, x2: number, y2: number) {
intersectsSegmentPolygon (polygon: NumberArrayLike, x1: number, y1: number, x2: number, y2: number) {
let vertices = polygon;
let nn = polygon.length;
@ -214,19 +214,19 @@ export class SkeletonBounds {
}
/** Returns the polygon for the specified bounding box, or null. */
getPolygon(boundingBox: BoundingBoxAttachment) {
getPolygon (boundingBox: BoundingBoxAttachment) {
if (!boundingBox) throw new Error("boundingBox cannot be null.");
let index = this.boundingBoxes.indexOf(boundingBox);
return index == -1 ? null : this.polygons[index];
}
/** The width of the axis aligned bounding box. */
getWidth() {
getWidth () {
return this.maxX - this.minX;
}
/** The height of the axis aligned bounding box. */
getHeight() {
getHeight () {
return this.maxY - this.minY;
}
}

14
spine-ts/spine-core/src/SkeletonClipping.ts
View File

@ -43,7 +43,7 @@ export class SkeletonClipping {
private clipAttachment: ClippingAttachment;
private clippingPolygons: Array<Array<number>>;
clipStart(slot: Slot, clip: ClippingAttachment): number {
clipStart (slot: Slot, clip: ClippingAttachment): number {
if (this.clipAttachment) return 0;
this.clipAttachment = clip;
@ -63,11 +63,11 @@ export class SkeletonClipping {
return clippingPolygons.length;
}
clipEndWithSlot(slot: Slot) {
clipEndWithSlot (slot: Slot) {
if (this.clipAttachment && this.clipAttachment.endSlot == slot.data) this.clipEnd();
}
clipEnd() {
clipEnd () {
if (!this.clipAttachment) return;
this.clipAttachment = null;
this.clippingPolygons = null;
@ -76,11 +76,11 @@ export class SkeletonClipping {
this.clippingPolygon.length = 0;
}
isClipping(): boolean {
isClipping (): boolean {
return this.clipAttachment != null;
}
clipTriangles(vertices: NumberArrayLike, verticesLength: number, triangles: NumberArrayLike, trianglesLength: number, uvs: NumberArrayLike,
clipTriangles (vertices: NumberArrayLike, verticesLength: number, triangles: NumberArrayLike, trianglesLength: number, uvs: NumberArrayLike,
light: Color, dark: Color, twoColor: boolean) {
let clipOutput = this.clipOutput, clippedVertices = this.clippedVertices;
@ -229,7 +229,7 @@ export class SkeletonClipping {
/** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping
* area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */
clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>) {
clip (x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>) {
let originalOutput = output;
let clipped = false;
@ -324,7 +324,7 @@ export class SkeletonClipping {
return clipped;
}
public static makeClockwise(polygon: NumberArrayLike) {
public static makeClockwise (polygon: NumberArrayLike) {
let vertices = polygon;
let verticeslength = polygon.length;

20
spine-ts/spine-core/src/SkeletonData.ts
View File

@ -104,7 +104,7 @@ export class SkeletonData {
/** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it
* multiple times.
* @returns May be null. */
findBone(boneName: string) {
findBone (boneName: string) {
if (!boneName) throw new Error("boneName cannot be null.");
let bones = this.bones;
for (let i = 0, n = bones.length; i < n; i++) {
@ -114,7 +114,7 @@ export class SkeletonData {
return null;
}
findBoneIndex(boneName: string) {
findBoneIndex (boneName: string) {
if (!boneName) throw new Error("boneName cannot be null.");
let bones = this.bones;
for (let i = 0, n = bones.length; i < n; i++)
@ -125,7 +125,7 @@ export class SkeletonData {
/** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
* multiple times.
* @returns May be null. */
findSlot(slotName: string) {
findSlot (slotName: string) {
if (!slotName) throw new Error("slotName cannot be null.");
let slots = this.slots;
for (let i = 0, n = slots.length; i < n; i++) {
@ -135,7 +135,7 @@ export class SkeletonData {
return null;
}
findSlotIndex(slotName: string) {
findSlotIndex (slotName: string) {
if (!slotName) throw new Error("slotName cannot be null.");
let slots = this.slots;
for (let i = 0, n = slots.length; i < n; i++)
@ -146,7 +146,7 @@ export class SkeletonData {
/** Finds a skin by comparing each skin's name. It is more efficient to cache the results of this method than to call it
* multiple times.
* @returns May be null. */
findSkin(skinName: string) {
findSkin (skinName: string) {
if (!skinName) throw new Error("skinName cannot be null.");
let skins = this.skins;
for (let i = 0, n = skins.length; i < n; i++) {
@ -159,7 +159,7 @@ export class SkeletonData {
/** Finds an event by comparing each events's name. It is more efficient to cache the results of this method than to call it
* multiple times.
* @returns May be null. */
findEvent(eventDataName: string) {
findEvent (eventDataName: string) {
if (!eventDataName) throw new Error("eventDataName cannot be null.");
let events = this.events;
for (let i = 0, n = events.length; i < n; i++) {
@ -172,7 +172,7 @@ export class SkeletonData {
/** Finds an animation by comparing each animation's name. It is more efficient to cache the results of this method than to
* call it multiple times.
* @returns May be null. */
findAnimation(animationName: string) {
findAnimation (animationName: string) {
if (!animationName) throw new Error("animationName cannot be null.");
let animations = this.animations;
for (let i = 0, n = animations.length; i < n; i++) {
@ -185,7 +185,7 @@ export class SkeletonData {
/** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
* than to call it multiple times.
* @return May be null. */
findIkConstraint(constraintName: string) {
findIkConstraint (constraintName: string) {
if (!constraintName) throw new Error("constraintName cannot be null.");
let ikConstraints = this.ikConstraints;
for (let i = 0, n = ikConstraints.length; i < n; i++) {
@ -198,7 +198,7 @@ export class SkeletonData {
/** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of
* this method than to call it multiple times.
* @return May be null. */
findTransformConstraint(constraintName: string) {
findTransformConstraint (constraintName: string) {
if (!constraintName) throw new Error("constraintName cannot be null.");
let transformConstraints = this.transformConstraints;
for (let i = 0, n = transformConstraints.length; i < n; i++) {
@ -211,7 +211,7 @@ export class SkeletonData {
/** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method
* than to call it multiple times.
* @return May be null. */
findPathConstraint(constraintName: string) {
findPathConstraint (constraintName: string) {
if (!constraintName) throw new Error("constraintName cannot be null.");
let pathConstraints = this.pathConstraints;
for (let i = 0, n = pathConstraints.length; i < n; i++) {

20
spine-ts/spine-core/src/SkeletonJson.ts
View File

@ -57,11 +57,11 @@ export class SkeletonJson {
scale = 1;
private linkedMeshes = new Array<LinkedMesh>();
constructor(attachmentLoader: AttachmentLoader) {
constructor (attachmentLoader: AttachmentLoader) {
this.attachmentLoader = attachmentLoader;
}
readSkeletonData(json: string | any): SkeletonData {
readSkeletonData (json: string | any): SkeletonData {
let scale = this.scale;
let skeletonData = new SkeletonData();
let root = typeof (json) === "string" ? JSON.parse(json) : json;
@ -291,7 +291,7 @@ export class SkeletonJson {
return skeletonData;
}
readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment {
readAttachment (map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment {
let scale = this.scale;
name = getValue(map, "name", name);
@ -399,7 +399,7 @@ export class SkeletonJson {
return null;
}
readVertices(map: any, attachment: VertexAttachment, verticesLength: number) {
readVertices (map: any, attachment: VertexAttachment, verticesLength: number) {
let scale = this.scale;
attachment.worldVerticesLength = verticesLength;
let vertices: Array<number> = map.vertices;
@ -428,7 +428,7 @@ export class SkeletonJson {
attachment.vertices = Utils.toFloatArray(weights);
}
readAnimation(map: any, name: string, skeletonData: SkeletonData) {
readAnimation (map: any, name: string, skeletonData: SkeletonData) {
let scale = this.scale;
let timelines = new Array<Timeline>();
@ -899,7 +899,7 @@ class LinkedMesh {
mesh: MeshAttachment;
inheritDeform: boolean;
constructor(mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {
constructor (mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {
this.mesh = mesh;
this.skin = skin;
this.slotIndex = slotIndex;
@ -908,7 +908,7 @@ class LinkedMesh {
}
}
function readTimeline1(keys: any[], timeline: CurveTimeline1, defaultValue: number, scale: number) {
function readTimeline1 (keys: any[], timeline: CurveTimeline1, defaultValue: number, scale: number) {
let keyMap = keys[0];
let time = getValue(keyMap, "time", 0);
let value = getValue(keyMap, "value", defaultValue) * scale;
@ -929,7 +929,7 @@ function readTimeline1(keys: any[], timeline: CurveTimeline1, defaultValue: numb
}
}
function readTimeline2(keys: any[], timeline: CurveTimeline2, name1: string, name2: string, defaultValue: number, scale: number) {
function readTimeline2 (keys: any[], timeline: CurveTimeline2, name1: string, name2: string, defaultValue: number, scale: number) {
let keyMap = keys[0];
let time = getValue(keyMap, "time", 0);
let value1 = getValue(keyMap, name1, defaultValue) * scale;
@ -957,7 +957,7 @@ function readTimeline2(keys: any[], timeline: CurveTimeline2, name1: string, nam
}
}
function readCurve(curve: any, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number,
function readCurve (curve: any, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number,
value1: number, value2: number, scale: number) {
if (curve == "stepped") {
timeline.setStepped(frame);
@ -972,6 +972,6 @@ function readCurve(curve: any, timeline: CurveTimeline, bezier: number, frame: n
return bezier + 1;
}
function getValue(map: any, property: string, defaultValue: any) {
function getValue (map: any, property: string, defaultValue: any) {
return map[property] !== undefined ? map[property] : defaultValue;
}

22
spine-ts/spine-core/src/Skin.ts
View File

@ -36,7 +36,7 @@ import { StringMap } from "./Utils";
/** Stores an entry in the skin consisting of the slot index, name, and attachment **/
export class SkinEntry {
constructor(public slotIndex: number, public name: string, public attachment: Attachment) { }
constructor (public slotIndex: number, public name: string, public attachment: Attachment) { }
}
/** Stores attachments by slot index and attachment name.
@ -51,13 +51,13 @@ export class Skin {
bones = Array<BoneData>();
constraints = new Array<ConstraintData>();
constructor(name: string) {
constructor (name: string) {
if (!name) throw new Error("name cannot be null.");
this.name = name;
}
/** Adds an attachment to the skin for the specified slot index and name. */
setAttachment(slotIndex: number, name: string, attachment: Attachment) {
setAttachment (slotIndex: number, name: string, attachment: Attachment) {
if (!attachment) throw new Error("attachment cannot be null.");
let attachments = this.attachments;
if (slotIndex >= attachments.length) attachments.length = slotIndex + 1;
@ -66,7 +66,7 @@ export class Skin {
}
/** Adds all attachments, bones, and constraints from the specified skin to this skin. */
addSkin(skin: Skin) {
addSkin (skin: Skin) {
for (let i = 0; i < skin.bones.length; i++) {
let bone = skin.bones[i];
let contained = false;
@ -100,7 +100,7 @@ export class Skin {
/** Adds all bones and constraints and copies of all attachments from the specified skin to this skin. Mesh attachments are not
* copied, instead a new linked mesh is created. The attachment copies can be modified without affecting the originals. */
copySkin(skin: Skin) {
copySkin (skin: Skin) {
for (let i = 0; i < skin.bones.length; i++) {
let bone = skin.bones[i];
let contained = false;
@ -140,19 +140,19 @@ export class Skin {
}
/** Returns the attachment for the specified slot index and name, or null. */
getAttachment(slotIndex: number, name: string): Attachment {
getAttachment (slotIndex: number, name: string): Attachment {
let dictionary = this.attachments[slotIndex];
return dictionary ? dictionary[name] : null;
}
/** Removes the attachment in the skin for the specified slot index and name, if any. */
removeAttachment(slotIndex: number, name: string) {
removeAttachment (slotIndex: number, name: string) {
let dictionary = this.attachments[slotIndex];
if (dictionary) dictionary[name] = null;
}
/** Returns all attachments in this skin. */
getAttachments(): Array<SkinEntry> {
getAttachments (): Array<SkinEntry> {
let entries = new Array<SkinEntry>();
for (var i = 0; i < this.attachments.length; i++) {
let slotAttachments = this.attachments[i];
@ -167,7 +167,7 @@ export class Skin {
}
/** Returns all attachments in this skin for the specified slot index. */
getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>) {
getAttachmentsForSlot (slotIndex: number, attachments: Array<SkinEntry>) {
let slotAttachments = this.attachments[slotIndex];
if (slotAttachments) {
for (let name in slotAttachments) {
@ -178,14 +178,14 @@ export class Skin {
}
/** Clears all attachments, bones, and constraints. */
clear() {
clear () {
this.attachments.length = 0;
this.bones.length = 0;
this.constraints.length = 0;
}
/** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */
attachAll(skeleton: Skeleton, oldSkin: Skin) {
attachAll (skeleton: Skeleton, oldSkin: Skin) {
let slotIndex = 0;
for (let i = 0; i < skeleton.slots.length; i++) {
let slot = skeleton.slots[i];

14
spine-ts/spine-core/src/Slot.ts
View File

@ -63,7 +63,7 @@ export class Slot {
* See {@link VertexAttachment#computeWorldVertices()} and {@link DeformTimeline}. */
deform = new Array<number>();
constructor(data: SlotData, bone: Bone) {
constructor (data: SlotData, bone: Bone) {
if (!data) throw new Error("data cannot be null.");
if (!bone) throw new Error("bone cannot be null.");
this.data = data;
@ -74,12 +74,12 @@ export class Slot {
}
/** The skeleton this slot belongs to. */
getSkeleton(): Skeleton {
getSkeleton (): Skeleton {
return this.bone.skeleton;
}
/** The current attachment for the slot, or null if the slot has no attachment. */
getAttachment(): Attachment {
getAttachment (): Attachment {
return this.attachment;
}
@ -87,7 +87,7 @@ export class Slot {
* The deform is not cleared if the old attachment has the same {@link VertexAttachment#getDeformAttachment()} as the specified
* attachment.
* @param attachment May be null. */
setAttachment(attachment: Attachment) {
setAttachment (attachment: Attachment) {
if (this.attachment == attachment) return;
if (!(attachment instanceof VertexAttachment) || !(this.attachment instanceof VertexAttachment)
|| (<VertexAttachment>attachment).deformAttachment != (<VertexAttachment>this.attachment).deformAttachment) {
@ -97,18 +97,18 @@ export class Slot {
this.attachmentTime = this.bone.skeleton.time;
}
setAttachmentTime(time: number) {
setAttachmentTime (time: number) {
this.attachmentTime = this.bone.skeleton.time - time;
}
/** The time that has elapsed since the last time the attachment was set or cleared. Relies on Skeleton
* {@link Skeleton#time}. */
getAttachmentTime(): number {
getAttachmentTime (): number {
return this.bone.skeleton.time - this.attachmentTime;
}
/** Sets this slot to the setup pose. */
setToSetupPose() {
setToSetupPose () {
this.color.setFromColor(this.data.color);
if (this.darkColor) this.darkColor.setFromColor(this.data.darkColor);
if (!this.data.attachmentName)

2
spine-ts/spine-core/src/SlotData.ts
View File

@ -55,7 +55,7 @@ export class SlotData {
/** The blend mode for drawing the slot's attachment. */
blendMode: BlendMode;
constructor(index: number, name: string, boneData: BoneData) {
constructor (index: number, name: string, boneData: BoneData) {
if (index < 0) throw new Error("index must be >= 0.");
if (!name) throw new Error("name cannot be null.");
if (!boneData) throw new Error("boneData cannot be null.");

16
spine-ts/spine-core/src/Texture.ts
View File

@ -30,17 +30,17 @@
export abstract class Texture {
protected _image: HTMLImageElement | ImageBitmap;
constructor(image: HTMLImageElement | ImageBitmap) {
constructor (image: HTMLImageElement | ImageBitmap) {
this._image = image;
}
getImage(): HTMLImageElement | ImageBitmap {
getImage (): HTMLImageElement | ImageBitmap {
return this._image;
}
abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
abstract dispose(): void;
abstract setFilters (minFilter: TextureFilter, magFilter: TextureFilter): void;
abstract setWraps (uWrap: TextureWrap, vWrap: TextureWrap): void;
abstract dispose (): void;
}
export enum TextureFilter {
@ -70,7 +70,7 @@ export class TextureRegion {
}
export class FakeTexture extends Texture {
setFilters(minFilter: TextureFilter, magFilter: TextureFilter) { }
setWraps(uWrap: TextureWrap, vWrap: TextureWrap) { }
dispose() { }
setFilters (minFilter: TextureFilter, magFilter: TextureFilter) { }
setWraps (uWrap: TextureWrap, vWrap: TextureWrap) { }
dispose () { }
}

16
spine-ts/spine-core/src/TextureAtlas.ts
View File

@ -35,7 +35,7 @@ export class TextureAtlas implements Disposable {
pages = new Array<TextureAtlasPage>();
regions = new Array<TextureAtlasRegion>();
constructor(atlasText: string) {
constructor (atlasText: string) {
let reader = new TextureAtlasReader(atlasText);
let entry = new Array<string>(4);
let page: TextureAtlasPage = null;
@ -176,7 +176,7 @@ export class TextureAtlas implements Disposable {
}
}
findRegion(name: string): TextureAtlasRegion {
findRegion (name: string): TextureAtlasRegion {
for (let i = 0; i < this.regions.length; i++) {
if (this.regions[i].name == name) {
return this.regions[i];
@ -185,12 +185,12 @@ export class TextureAtlas implements Disposable {
return null;
}
setTextures(assetManager: AssetManagerBase, pathPrefix: string = "") {
setTextures (assetManager: AssetManagerBase, pathPrefix: string = "") {
for (let page of this.pages)
page.setTexture(assetManager.get(pathPrefix + page.name));
}
dispose() {
dispose () {
for (let i = 0; i < this.pages.length; i++) {
this.pages[i].texture.dispose();
}
@ -201,17 +201,17 @@ class TextureAtlasReader {
lines: Array<string>;
index: number = 0;
constructor(text: string) {
constructor (text: string) {
this.lines = text.split(/\r\n|\r|\n/);
}
readLine(): string {
readLine (): string {
if (this.index >= this.lines.length)
return null;
return this.lines[this.index++];
}
readEntry(entry: string[], line: string): number {
readEntry (entry: string[], line: string): number {
if (!line) return 0;
line = line.trim();
if (line.length == 0) return 0;
@ -243,7 +243,7 @@ export class TextureAtlasPage {
height: number;
pma: boolean;
setTexture(texture: Texture) {
setTexture (texture: Texture) {
this.texture = texture;
texture.setFilters(this.minFilter, this.magFilter);
texture.setWraps(this.uWrap, this.vWrap);

14
spine-ts/spine-core/src/TransformConstraint.ts
View File

@ -54,7 +54,7 @@ export class TransformConstraint implements Updatable {
temp = new Vector2();
active = false;
constructor(data: TransformConstraintData, skeleton: Skeleton) {
constructor (data: TransformConstraintData, skeleton: Skeleton) {
if (!data) throw new Error("data cannot be null.");
if (!skeleton) throw new Error("skeleton cannot be null.");
this.data = data;
@ -70,11 +70,11 @@ export class TransformConstraint implements Updatable {
this.target = skeleton.findBone(data.target.name);
}
isActive() {
isActive () {
return this.active;
}
update() {
update () {
if (this.mixRotate == 0 && this.mixX == 0 && this.mixY == 0 && this.mixScaleX == 0 && this.mixScaleX == 0 && this.mixShearY == 0) return;
if (this.data.local) {
@ -90,7 +90,7 @@ export class TransformConstraint implements Updatable {
}
}
applyAbsoluteWorld() {
applyAbsoluteWorld () {
let mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
let translate = mixX != 0 || mixY != 0;
@ -158,7 +158,7 @@ export class TransformConstraint implements Updatable {
}
}
applyRelativeWorld() {
applyRelativeWorld () {
let mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
let translate = mixX != 0 || mixY != 0;
@ -222,7 +222,7 @@ export class TransformConstraint implements Updatable {
}
}
applyAbsoluteLocal() {
applyAbsoluteLocal () {
let mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
@ -260,7 +260,7 @@ export class TransformConstraint implements Updatable {
}
}
applyRelativeLocal() {
applyRelativeLocal () {
let mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;

2
spine-ts/spine-core/src/TransformConstraintData.ts
View File

@ -69,7 +69,7 @@ export class TransformConstraintData extends ConstraintData {
relative = false;
local = false;
constructor(name: string) {
constructor (name: string) {
super(name, 0, false);
}
}

10
spine-ts/spine-core/src/Triangulator.ts
View File

@ -45,7 +45,7 @@ export class Triangulator {
return new Array<number>();
});
public triangulate(verticesArray: NumberArrayLike): Array<number> {
public triangulate (verticesArray: NumberArrayLike): Array<number> {
let vertices = verticesArray;
let vertexCount = verticesArray.length >> 1;
@ -121,7 +121,7 @@ export class Triangulator {
return triangles;
}
decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>> {
decompose (verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>> {
let vertices = verticesArray;
let convexPolygons = this.convexPolygons;
this.polygonPool.freeAll(convexPolygons);
@ -250,7 +250,7 @@ export class Triangulator {
return convexPolygons;
}
private static isConcave(index: number, vertexCount: number, vertices: NumberArrayLike, indices: NumberArrayLike): boolean {
private static isConcave (index: number, vertexCount: number, vertices: NumberArrayLike, indices: NumberArrayLike): boolean {
let previous = indices[(vertexCount + index - 1) % vertexCount] << 1;
let current = indices[index] << 1;
let next = indices[(index + 1) % vertexCount] << 1;
@ -258,11 +258,11 @@ export class Triangulator {
vertices[next + 1]);
}
private static positiveArea(p1x: number, p1y: number, p2x: number, p2y: number, p3x: number, p3y: number): boolean {
private static positiveArea (p1x: number, p1y: number, p2x: number, p2y: number, p3x: number, p3y: number): boolean {
return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0;
}
private static winding(p1x: number, p1y: number, p2x: number, p2y: number, p3x: number, p3y: number): number {
private static winding (p1x: number, p1y: number, p2x: number, p2y: number, p3x: number, p3y: number): number {
let px = p2x - p1x, py = p2y - p1y;
return p3x * py - p3y * px + px * p1y - p1x * py >= 0 ? 1 : -1;
}

4
spine-ts/spine-core/src/Updatable.ts
View File

@ -29,11 +29,11 @@
/** The interface for items updated by {@link Skeleton#updateWorldTransform()}. */
export interface Updatable {
update(): void;
update (): void;
/** Returns false when this item has not been updated because a skin is required and the {@link Skeleton#skin active skin}
* does not contain this item.
* @see Skin#getBones()
* @see Skin#getConstraints() */
isActive(): boolean;
isActive (): boolean;
}

122
spine-ts/spine-core/src/Utils.ts
View File

@ -37,21 +37,21 @@ export interface StringMap<T> {
export class IntSet {
array = new Array<number>();
add(value: number): boolean {
add (value: number): boolean {
let contains = this.contains(value);
this.array[value | 0] = value | 0;
return !contains;
}
contains(value: number) {
contains (value: number) {
return this.array[value | 0] != undefined;
}
remove(value: number) {
remove (value: number) {
this.array[value | 0] = undefined;
}
clear() {
clear () {
this.array.length = 0;
}
}
@ -60,7 +60,7 @@ export class StringSet {
entries: StringMap<boolean> = {};
size = 0;
add(value: string): boolean {
add (value: string): boolean {
let contains = this.entries[value];
this.entries[value] = true;
if (!contains) {
@ -70,18 +70,18 @@ export class StringSet {
return false;
}
addAll(values: string[]): boolean {
addAll (values: string[]): boolean {
let oldSize = this.size;
for (var i = 0, n = values.length; i < n; i++)
this.add(values[i]);
return oldSize != this.size;
}
contains(value: string) {
contains (value: string) {
return this.entries[value];
}
clear() {
clear () {
this.entries = {};
this.size = 0;
}
@ -93,11 +93,11 @@ export interface NumberArrayLike {
}
export interface Disposable {
dispose(): void;
dispose (): void;
}
export interface Restorable {
restore(): void;
restore (): void;
}
export class Color {
@ -107,10 +107,10 @@ export class Color {
public static BLUE = new Color(0, 0, 1, 1);
public static MAGENTA = new Color(1, 0, 1, 1);
constructor(public r: number = 0, public g: number = 0, public b: number = 0, public a: number = 0) {
constructor (public r: number = 0, public g: number = 0, public b: number = 0, public a: number = 0) {
}
set(r: number, g: number, b: number, a: number) {
set (r: number, g: number, b: number, a: number) {
this.r = r;
this.g = g;
this.b = b;
@ -118,7 +118,7 @@ export class Color {
return this.clamp();
}
setFromColor(c: Color) {
setFromColor (c: Color) {
this.r = c.r;
this.g = c.g;
this.b = c.b;
@ -126,7 +126,7 @@ export class Color {
return this;
}
setFromString(hex: string) {
setFromString (hex: string) {
hex = hex.charAt(0) == '#' ? hex.substr(1) : hex;
this.r = parseInt(hex.substr(0, 2), 16) / 255;
this.g = parseInt(hex.substr(2, 2), 16) / 255;
@ -135,7 +135,7 @@ export class Color {
return this;
}
add(r: number, g: number, b: number, a: number) {
add (r: number, g: number, b: number, a: number) {
this.r += r;
this.g += g;
this.b += b;
@ -143,7 +143,7 @@ export class Color {
return this.clamp();
}
clamp() {
clamp () {
if (this.r < 0) this.r = 0;
else if (this.r > 1) this.r = 1;
@ -158,20 +158,20 @@ export class Color {
return this;
}
static rgba8888ToColor(color: Color, value: number) {
static rgba8888ToColor (color: Color, value: number) {
color.r = ((value & 0xff000000) >>> 24) / 255;
color.g = ((value & 0x00ff0000) >>> 16) / 255;
color.b = ((value & 0x0000ff00) >>> 8) / 255;
color.a = ((value & 0x000000ff)) / 255;
}
static rgb888ToColor(color: Color, value: number) {
static rgb888ToColor (color: Color, value: number) {
color.r = ((value & 0x00ff0000) >>> 16) / 255;
color.g = ((value & 0x0000ff00) >>> 8) / 255;
color.b = ((value & 0x000000ff)) / 255;
}
static fromString(hex: string): Color {
static fromString (hex: string): Color {
return new Color().setFromString(hex);
}
}
@ -184,52 +184,52 @@ export class MathUtils {
static degreesToRadians = MathUtils.PI / 180;
static degRad = MathUtils.degreesToRadians;
static clamp(value: number, min: number, max: number) {
static clamp (value: number, min: number, max: number) {
if (value < min) return min;
if (value > max) return max;
return value;
}
static cosDeg(degrees: number) {
static cosDeg (degrees: number) {
return Math.cos(degrees * MathUtils.degRad);
}
static sinDeg(degrees: number) {
static sinDeg (degrees: number) {
return Math.sin(degrees * MathUtils.degRad);
}
static signum(value: number): number {
static signum (value: number): number {
return value > 0 ? 1 : value < 0 ? -1 : 0;
}
static toInt(x: number) {
static toInt (x: number) {
return x > 0 ? Math.floor(x) : Math.ceil(x);
}
static cbrt(x: number) {
static cbrt (x: number) {
let y = Math.pow(Math.abs(x), 1 / 3);
return x < 0 ? -y : y;
}
static randomTriangular(min: number, max: number): number {
static randomTriangular (min: number, max: number): number {
return MathUtils.randomTriangularWith(min, max, (min + max) * 0.5);
}
static randomTriangularWith(min: number, max: number, mode: number): number {
static randomTriangularWith (min: number, max: number, mode: number): number {
let u = Math.random();
let d = max - min;
if (u <= (mode - min) / d) return min + Math.sqrt(u * d * (mode - min));
return max - Math.sqrt((1 - u) * d * (max - mode));
}
static isPowerOfTwo(value: number) {
static isPowerOfTwo (value: number) {
return value && (value & (value - 1)) === 0;
}
}
export abstract class Interpolation {
protected abstract applyInternal(a: number): number;
apply(start: number, end: number, a: number): number {
protected abstract applyInternal (a: number): number;
apply (start: number, end: number, a: number): number {
return start + (end - start) * this.applyInternal(a);
}
}
@ -237,23 +237,23 @@ export abstract class Interpolation {
export class Pow extends Interpolation {
protected power = 2;
constructor(power: number) {
constructor (power: number) {
super();
this.power = power;
}
applyInternal(a: number): number {
applyInternal (a: number): number {
if (a <= 0.5) return Math.pow(a * 2, this.power) / 2;
return Math.pow((a - 1) * 2, this.power) / (this.power % 2 == 0 ? -2 : 2) + 1;
}
}
export class PowOut extends Pow {
constructor(power: number) {
constructor (power: number) {
super(power);
}
applyInternal(a: number): number {
applyInternal (a: number): number {
return Math.pow(a - 1, this.power) * (this.power % 2 == 0 ? -1 : 1) + 1;
}
}
@ -261,18 +261,18 @@ export class PowOut extends Pow {
export class Utils {
static SUPPORTS_TYPED_ARRAYS = typeof (Float32Array) !== "undefined";
static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number) {
static arrayCopy<T> (source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number) {
for (let i = sourceStart, j = destStart; i < sourceStart + numElements; i++, j++) {
dest[j] = source[i];
}
}
static arrayFill<T>(array: ArrayLike<T>, fromIndex: number, toIndex: number, value: T) {
static arrayFill<T> (array: ArrayLike<T>, fromIndex: number, toIndex: number, value: T) {
for (let i = fromIndex; i < toIndex; i++)
array[i] = value;
}
static setArraySize<T>(array: Array<T>, size: number, value: any = 0): Array<T> {
static setArraySize<T> (array: Array<T>, size: number, value: any = 0): Array<T> {
let oldSize = array.length;
if (oldSize == size) return array;
array.length = size;
@ -282,18 +282,18 @@ export class Utils {
return array;
}
static ensureArrayCapacity<T>(array: Array<T>, size: number, value: any = 0): Array<T> {
static ensureArrayCapacity<T> (array: Array<T>, size: number, value: any = 0): Array<T> {
if (array.length >= size) return array;
return Utils.setArraySize(array, size, value);
}
static newArray<T>(size: number, defaultValue: T): Array<T> {
static newArray<T> (size: number, defaultValue: T): Array<T> {
let array = new Array<T>(size);
for (let i = 0; i < size; i++) array[i] = defaultValue;
return array;
}
static newFloatArray(size: number): NumberArrayLike {
static newFloatArray (size: number): NumberArrayLike {
if (Utils.SUPPORTS_TYPED_ARRAYS)
return new Float32Array(size)
else {
@ -303,7 +303,7 @@ export class Utils {
}
}
static newShortArray(size: number): NumberArrayLike {
static newShortArray (size: number): NumberArrayLike {
if (Utils.SUPPORTS_TYPED_ARRAYS)
return new Int16Array(size)
else {
@ -313,31 +313,31 @@ export class Utils {
}
}
static toFloatArray(array: Array<number>) {
static toFloatArray (array: Array<number>) {
return Utils.SUPPORTS_TYPED_ARRAYS ? new Float32Array(array) : array;
}
static toSinglePrecision(value: number) {
static toSinglePrecision (value: number) {
return Utils.SUPPORTS_TYPED_ARRAYS ? Math.fround(value) : value;
}
// This function is used to fix WebKit 602 specific issue described at http://esotericsoftware.com/forum/iOS-10-disappearing-graphics-10109
static webkit602BugfixHelper(alpha: number, blend: MixBlend) {
static webkit602BugfixHelper (alpha: number, blend: MixBlend) {
}
static contains<T>(array: Array<T>, element: T, identity = true) {
static contains<T> (array: Array<T>, element: T, identity = true) {
for (var i = 0; i < array.length; i++)
if (array[i] == element) return true;
return false;
}
static enumValue(type: any, name: string) {
static enumValue (type: any, name: string) {
return type[name[0].toUpperCase() + name.slice(1)];
}
}
export class DebugUtils {
static logBones(skeleton: Skeleton) {
static logBones (skeleton: Skeleton) {
for (let i = 0; i < skeleton.bones.length; i++) {
let bone = skeleton.bones[i];
console.log(bone.data.name + ", " + bone.a + ", " + bone.b + ", " + bone.c + ", " + bone.d + ", " + bone.worldX + ", " + bone.worldY);
@ -349,46 +349,46 @@ export class Pool<T> {
private items = new Array<T>();
private instantiator: () => T;
constructor(instantiator: () => T) {
constructor (instantiator: () => T) {
this.instantiator = instantiator;
}
obtain() {
obtain () {
return this.items.length > 0 ? this.items.pop() : this.instantiator();
}
free(item: T) {
free (item: T) {
if ((item as any).reset) (item as any).reset();
this.items.push(item);
}
freeAll(items: ArrayLike<T>) {
freeAll (items: ArrayLike<T>) {
for (let i = 0; i < items.length; i++)
this.free(items[i]);
}
clear() {
clear () {
this.items.length = 0;
}
}
export class Vector2 {
constructor(public x = 0, public y = 0) {
constructor (public x = 0, public y = 0) {
}
set(x: number, y: number): Vector2 {
set (x: number, y: number): Vector2 {
this.x = x;
this.y = y;
return this;
}
length() {
length () {
let x = this.x;
let y = this.y;
return Math.sqrt(x * x + y * y);
}
normalize() {
normalize () {
let len = this.length();
if (len != 0) {
this.x /= len;
@ -408,7 +408,7 @@ export class TimeKeeper {
private frameCount = 0;
private frameTime = 0;
update() {
update () {
let now = Date.now() / 1000;
this.delta = now - this.lastTime;
this.frameTime += this.delta;
@ -437,22 +437,22 @@ export class WindowedMean {
mean = 0;
dirty = true;
constructor(windowSize: number = 32) {
constructor (windowSize: number = 32) {
this.values = new Array<number>(windowSize);
}
hasEnoughData() {
hasEnoughData () {
return this.addedValues >= this.values.length;
}
addValue(value: number) {
addValue (value: number) {
if (this.addedValues < this.values.length) this.addedValues++;
this.values[this.lastValue++] = value;
if (this.lastValue > this.values.length - 1) this.lastValue = 0;
this.dirty = true;
}
getMean() {
getMean () {
if (this.hasEnoughData()) {
if (this.dirty) {
let mean = 0;

6
spine-ts/spine-core/src/VertexEffect.ts
View File

@ -31,7 +31,7 @@ import { Skeleton } from "./Skeleton";
import { Vector2, Color } from "./Utils";
export interface VertexEffect {
begin(skeleton: Skeleton): void;
transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
end(): void;
begin (skeleton: Skeleton): void;
transform (position: Vector2, uv: Vector2, light: Color, dark: Color): void;
end (): void;
}

10
spine-ts/spine-core/src/attachments/Attachment.ts
View File

@ -34,12 +34,12 @@ import { NumberArrayLike, Utils } from "../Utils";
export abstract class Attachment {
name: string;
constructor(name: string) {
constructor (name: string) {
if (!name) throw new Error("name cannot be null.");
this.name = name;
}
abstract copy(): Attachment;
abstract copy (): Attachment;
}
/** Base class for an attachment with vertices that are transformed by one or more bones and can be deformed by a slot's
@ -67,7 +67,7 @@ export abstract class VertexAttachment extends Attachment {
/** Deform keys for the deform attachment are also applied to this attachment. May be null if no deform keys should be applied. */
deformAttachment: VertexAttachment = this;
constructor(name: string) {
constructor (name: string) {
super(name);
}
@ -82,7 +82,7 @@ export abstract class VertexAttachment extends Attachment {
* `stride` / 2.
* @param offset The `worldVertices` index to begin writing values.
* @param stride The number of `worldVertices` entries between the value pairs written. */
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: NumberArrayLike, offset: number, stride: number) {
computeWorldVertices (slot: Slot, start: number, count: number, worldVertices: NumberArrayLike, offset: number, stride: number) {
count = offset + (count >> 1) * stride;
let skeleton = slot.bone.skeleton;
let deformArray = slot.deform;
@ -141,7 +141,7 @@ export abstract class VertexAttachment extends Attachment {
}
/** Does not copy id (generated) or name (set on construction). **/
copyTo(attachment: VertexAttachment) {
copyTo (attachment: VertexAttachment) {
if (this.bones) {
attachment.bones = new Array<number>(this.bones.length);
Utils.arrayCopy(this.bones, 0, attachment.bones, 0, this.bones.length);

12
spine-ts/spine-core/src/attachments/AttachmentLoader.ts
View File

@ -41,20 +41,20 @@ import { RegionAttachment } from "./RegionAttachment";
* Runtimes Guide. */
export interface AttachmentLoader {
/** @return May be null to not load an attachment. */
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
newRegionAttachment (skin: Skin, name: string, path: string): RegionAttachment;
/** @return May be null to not load an attachment. */
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
newMeshAttachment (skin: Skin, name: string, path: string): MeshAttachment;
/** @return May be null to not load an attachment. */
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
newBoundingBoxAttachment (skin: Skin, name: string): BoundingBoxAttachment;
/** @return May be null to not load an attachment */
newPathAttachment(skin: Skin, name: string): PathAttachment;
newPathAttachment (skin: Skin, name: string): PathAttachment;
/** @return May be null to not load an attachment */
newPointAttachment(skin: Skin, name: string): PointAttachment;
newPointAttachment (skin: Skin, name: string): PointAttachment;
/** @return May be null to not load an attachment */
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
newClippingAttachment (skin: Skin, name: string): ClippingAttachment;
}

4
spine-ts/spine-core/src/attachments/BoundingBoxAttachment.ts
View File

@ -38,11 +38,11 @@ import { VertexAttachment, Attachment } from "./Attachment";
export class BoundingBoxAttachment extends VertexAttachment {
color = new Color(1, 1, 1, 1);
constructor(name: string) {
constructor (name: string) {
super(name);
}
copy(): Attachment {
copy (): Attachment {
let copy = new BoundingBoxAttachment(this.name);
this.copyTo(copy);
copy.color.setFromColor(this.color);

4
spine-ts/spine-core/src/attachments/ClippingAttachment.ts
View File

@ -42,11 +42,11 @@ export class ClippingAttachment extends VertexAttachment {
* are not usually rendered at runtime. */
color = new Color(0.2275, 0.2275, 0.8078, 1); // ce3a3aff
constructor(name: string) {
constructor (name: string) {
super(name);
}
copy(): Attachment {
copy (): Attachment {
let copy = new ClippingAttachment(this.name);
this.copyTo(copy);
copy.endSlot = this.endSlot;

12
spine-ts/spine-core/src/attachments/MeshAttachment.ts
View File

@ -72,13 +72,13 @@ export class MeshAttachment extends VertexAttachment {
private parentMesh: MeshAttachment;
tempColor = new Color(0, 0, 0, 0);
constructor(name: string) {
constructor (name: string) {
super(name);
}
/** Calculates {@link #uvs} using {@link #regionUVs} and the {@link #region}. Must be called after changing the region UVs or
* region. */
updateUVs() {
updateUVs () {
let regionUVs = this.regionUVs;
if (!this.uvs || this.uvs.length != regionUVs.length) this.uvs = Utils.newFloatArray(regionUVs.length);
let uvs = this.uvs;
@ -140,12 +140,12 @@ export class MeshAttachment extends VertexAttachment {
/** The parent mesh if this is a linked mesh, else null. A linked mesh shares the {@link #bones}, {@link #vertices},
* {@link #regionUVs}, {@link #triangles}, {@link #hullLength}, {@link #edges}, {@link #width}, and {@link #height} with the
* parent mesh, but may have a different {@link #name} or {@link #path} (and therefore a different texture). */
getParentMesh() {
getParentMesh () {
return this.parentMesh;
}
/** @param parentMesh May be null. */
setParentMesh(parentMesh: MeshAttachment) {
setParentMesh (parentMesh: MeshAttachment) {
this.parentMesh = parentMesh;
if (parentMesh) {
this.bones = parentMesh.bones;
@ -158,7 +158,7 @@ export class MeshAttachment extends VertexAttachment {
}
}
copy(): Attachment {
copy (): Attachment {
if (this.parentMesh) return this.newLinkedMesh();
let copy = new MeshAttachment(this.name);
@ -187,7 +187,7 @@ export class MeshAttachment extends VertexAttachment {
}
/** Returns a new mesh with the {@link #parentMesh} set to this mesh's parent mesh, if any, else to this mesh. **/
newLinkedMesh(): MeshAttachment {
newLinkedMesh (): MeshAttachment {
let copy = new MeshAttachment(this.name);
copy.region = this.region;
copy.path = this.path;

4
spine-ts/spine-core/src/attachments/PathAttachment.ts
View File

@ -49,11 +49,11 @@ export class PathAttachment extends VertexAttachment {
* rendered at runtime. */
color = new Color(1, 1, 1, 1);
constructor(name: string) {
constructor (name: string) {
super(name);
}
copy(): Attachment {
copy (): Attachment {
let copy = new PathAttachment(this.name);
this.copyTo(copy);
copy.lengths = new Array<number>(this.lengths.length);

8
spine-ts/spine-core/src/attachments/PointAttachment.ts
View File

@ -43,24 +43,24 @@ export class PointAttachment extends VertexAttachment {
* are not usually rendered at runtime. */
color = new Color(0.38, 0.94, 0, 1);
constructor(name: string) {
constructor (name: string) {
super(name);
}
computeWorldPosition(bone: Bone, point: Vector2) {
computeWorldPosition (bone: Bone, point: Vector2) {
point.x = this.x * bone.a + this.y * bone.b + bone.worldX;
point.y = this.x * bone.c + this.y * bone.d + bone.worldY;
return point;
}
computeWorldRotation(bone: Bone) {
computeWorldRotation (bone: Bone) {
let cos = MathUtils.cosDeg(this.rotation), sin = MathUtils.sinDeg(this.rotation);
let x = cos * bone.a + sin * bone.b;
let y = cos * bone.c + sin * bone.d;
return Math.atan2(y, x) * MathUtils.radDeg;
}
copy(): Attachment {
copy (): Attachment {
let copy = new PointAttachment(this.name);
copy.x = this.x;
copy.y = this.y;

10
spine-ts/spine-core/src/attachments/RegionAttachment.ts
View File

@ -75,12 +75,12 @@ export class RegionAttachment extends Attachment {
tempColor = new Color(1, 1, 1, 1);
constructor(name: string) {
constructor (name: string) {
super(name);
}
/** Calculates the {@link #offset} using the region settings. Must be called after changing region settings. */
updateOffset(): void {
updateOffset (): void {
let region = this.region;
let regionScaleX = this.width / this.region.originalWidth * this.scaleX;
let regionScaleY = this.height / this.region.originalHeight * this.scaleY;
@ -111,7 +111,7 @@ export class RegionAttachment extends Attachment {
offset[7] = localYCos + localX2Sin;
}
setRegion(region: TextureRegion): void {
setRegion (region: TextureRegion): void {
this.region = region;
let uvs = this.uvs;
if (region.degrees == 90) {
@ -142,7 +142,7 @@ export class RegionAttachment extends Attachment {
* @param worldVertices The output world vertices. Must have a length >= `offset` + 8.
* @param offset The `worldVertices` index to begin writing values.
* @param stride The number of `worldVertices` entries between the value pairs written. */
computeWorldVertices(bone: Bone, worldVertices: NumberArrayLike, offset: number, stride: number) {
computeWorldVertices (bone: Bone, worldVertices: NumberArrayLike, offset: number, stride: number) {
let vertexOffset = this.offset;
let x = bone.worldX, y = bone.worldY;
let a = bone.a, b = bone.b, c = bone.c, d = bone.d;
@ -172,7 +172,7 @@ export class RegionAttachment extends Attachment {
worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
}
copy(): Attachment {
copy (): Attachment {
let copy = new RegionAttachment(this.name);
copy.region = this.region;
copy.rendererObject = this.rendererObject;

8
spine-ts/spine-core/src/vertexeffects/JitterEffect.ts
View File

@ -35,19 +35,19 @@ export class JitterEffect implements VertexEffect {
jitterX = 0;
jitterY = 0;
constructor(jitterX: number, jitterY: number) {
constructor (jitterX: number, jitterY: number) {
this.jitterX = jitterX;
this.jitterY = jitterY;
}
begin(skeleton: Skeleton): void {
begin (skeleton: Skeleton): void {
}
transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void {
transform (position: Vector2, uv: Vector2, light: Color, dark: Color): void {
position.x += MathUtils.randomTriangular(-this.jitterX, this.jitterY);
position.y += MathUtils.randomTriangular(-this.jitterX, this.jitterY);
}
end(): void {
end (): void {
}
}

8
spine-ts/spine-core/src/vertexeffects/SwirlEffect.ts
View File

@ -40,16 +40,16 @@ export class SwirlEffect implements VertexEffect {
private worldX = 0;
private worldY = 0;
constructor(radius: number) {
constructor (radius: number) {
this.radius = radius;
}
begin(skeleton: Skeleton): void {
begin (skeleton: Skeleton): void {
this.worldX = skeleton.x + this.centerX;
this.worldY = skeleton.y + this.centerY;
}
transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void {
transform (position: Vector2, uv: Vector2, light: Color, dark: Color): void {
let radAngle = this.angle * MathUtils.degreesToRadians;
let x = position.x - this.worldX;
let y = position.y - this.worldY;
@ -63,6 +63,6 @@ export class SwirlEffect implements VertexEffect {
}
}
end(): void {
end (): void {
}
}

68
spine-ts/spine-player/src/Player.ts
View File

@ -217,7 +217,7 @@ export class SpinePlayer {
private previousViewport: Viewport;
private viewportTransitionStart = 0;
constructor(parent: HTMLElement | string, private config: SpinePlayerConfig) {
constructor (parent: HTMLElement | string, private config: SpinePlayerConfig) {
this.parent = typeof parent === "string" ? document.getElementById(parent) : parent;
if (!this.parent) throw new Error("SpinePlayer parent not found: " + parent);
@ -254,7 +254,7 @@ export class SpinePlayer {
requestAnimationFrame(() => this.drawFrame());
}
private validateConfig(config: SpinePlayerConfig) {
private validateConfig (config: SpinePlayerConfig) {
if (!config) throw new Error("A configuration object must be passed to to new SpinePlayer().");
if ((config as any).skelUrl) config.binaryUrl = (config as any).skelUrl;
if (!config.jsonUrl && !config.binaryUrl) throw new Error("A URL must be specified for the skeleton JSON or binary file.");
@ -278,7 +278,7 @@ export class SpinePlayer {
if (config.defaultMix === void 0) config.defaultMix = 0.25;
}
private initialize(): HTMLElement {
private initialize (): HTMLElement {
let config = this.config;
let dom = this.dom;
@ -391,7 +391,7 @@ export class SpinePlayer {
return dom;
}
private loadSkeleton() {
private loadSkeleton () {
if (this.error) return;
if (this.assetManager.hasErrors())
@ -515,7 +515,7 @@ export class SpinePlayer {
}
}
private setupInput() {
private setupInput () {
let config = this.config;
let controlBones = config.controlBones;
if (!controlBones.length && !config.showControls) return;
@ -621,7 +621,7 @@ export class SpinePlayer {
}
}
play() {
play () {
this.paused = false;
let config = this.config;
if (config.showControls) {
@ -642,7 +642,7 @@ export class SpinePlayer {
}
}
pause() {
pause () {
this.paused = true;
if (this.config.showControls) {
this.playerControls.classList.remove("spine-player-controls-hidden");
@ -653,19 +653,19 @@ export class SpinePlayer {
}
/* Sets a new animation and viewport on track 0. */
setAnimation(animation: string | Animation, loop: boolean = true): TrackEntry {
setAnimation (animation: string | Animation, loop: boolean = true): TrackEntry {
animation = this.setViewport(animation);
return this.animationState.setAnimationWith(0, animation, loop);
}
/* Adds a new animation and viewport on track 0. */
addAnimation(animation: string | Animation, loop: boolean = true, delay: number = 0): TrackEntry {
addAnimation (animation: string | Animation, loop: boolean = true, delay: number = 0): TrackEntry {
animation = this.setViewport(animation);
return this.animationState.addAnimationWith(0, animation, loop, delay);
}
/* Sets the viewport for the specified animation. */
setViewport(animation: string | Animation): Animation {
setViewport (animation: string | Animation): Animation {
if (typeof animation == "string") animation = this.skeleton.data.findAnimation(animation);
this.previousViewport = this.currentViewport;
@ -711,13 +711,13 @@ export class SpinePlayer {
return animation;
}
private percentageToWorldUnit(size: number, percentageOrAbsolute: string | number): number {
private percentageToWorldUnit (size: number, percentageOrAbsolute: string | number): number {
if (typeof percentageOrAbsolute === "string")
return size * parseFloat(percentageOrAbsolute.substr(0, percentageOrAbsolute.length - 1)) / 100;
return percentageOrAbsolute;
}
private calculateAnimationViewport(animation: Animation, viewport: Viewport) {
private calculateAnimationViewport (animation: Animation, viewport: Viewport) {
this.skeleton.setToSetupPose();
let steps = 100, stepTime = animation.duration ? animation.duration / steps : 0, time = 0;
@ -744,7 +744,7 @@ export class SpinePlayer {
viewport.height = maxY - minY;
}
private drawFrame(requestNextFrame = true) {
private drawFrame (requestNextFrame = true) {
try {
if (this.error) return;
if (requestNextFrame && !this.stopRequestAnimationFrame) requestAnimationFrame(() => this.drawFrame());
@ -884,15 +884,15 @@ export class SpinePlayer {
}
}
stopRendering() {
stopRendering () {
this.stopRequestAnimationFrame = true;
}
private hidePopup(id: string): boolean {
private hidePopup (id: string): boolean {
return this.popup && this.popup.hide(id);
}
private showSpeedDialog(speedButton: HTMLElement) {
private showSpeedDialog (speedButton: HTMLElement) {
let id = "speed";
if (this.hidePopup(id)) return;
@ -912,7 +912,7 @@ export class SpinePlayer {
popup.show();
}
private showAnimationsDialog(animationsButton: HTMLElement) {
private showAnimationsDialog (animationsButton: HTMLElement) {
let id = "animations";
if (this.hidePopup(id)) return;
if (!this.skeleton || !this.skeleton.data.animations.length) return;
@ -942,7 +942,7 @@ export class SpinePlayer {
popup.show();
}
private showSkinsDialog(skinButton: HTMLElement) {
private showSkinsDialog (skinButton: HTMLElement) {
let id = "skins";
if (this.hidePopup(id)) return;
if (!this.skeleton || !this.skeleton.data.animations.length) return;
@ -970,7 +970,7 @@ export class SpinePlayer {
popup.show();
}
private showSettingsDialog(settingsButton: HTMLElement) {
private showSettingsDialog (settingsButton: HTMLElement) {
let id = "settings";
if (this.hidePopup(id)) return;
if (!this.skeleton || !this.skeleton.data.animations.length) return;
@ -998,7 +998,7 @@ export class SpinePlayer {
popup.show();
}
private showError(message: string, error: Error = null) {
private showError (message: string, error: Error = null) {
if (this.error) {
if (error) throw error; // Don't lose error if showError throws, is caught, and showError is called again.
} else {
@ -1016,14 +1016,14 @@ class Popup {
public dom: HTMLElement;
private className: string;
constructor(private id: string, private button: HTMLElement, private player: SpinePlayer, parent: HTMLElement, htmlContent: string) {
constructor (private id: string, private button: HTMLElement, private player: SpinePlayer, parent: HTMLElement, htmlContent: string) {
this.dom = createElement(/*html*/`<div class="spine-player-popup spine-player-hidden"></div>`);
this.dom.innerHTML = htmlContent;
parent.appendChild(this.dom);
this.className = "spine-player-button-icon-" + id + "-selected";
}
hide(id: string): boolean {
hide (id: string): boolean {
this.dom.remove();
this.button.classList.remove(this.className);
if (this.id == id) {
@ -1032,7 +1032,7 @@ class Popup {
}
}
show() {
show () {
this.player.popup = this;
this.button.classList.add(this.className);
this.dom.classList.remove("spine-player-hidden");
@ -1072,9 +1072,9 @@ class Switch {
private enabled = false;
public change: (value: boolean) => void;
constructor(private text: string) { }
constructor (private text: string) { }
create(): HTMLElement {
create (): HTMLElement {
this.switch = createElement(/*html*/`
<div class="spine-player-switch">
<span class="spine-player-switch-text">${this.text}</span>
@ -1089,13 +1089,13 @@ class Switch {
return this.switch;
}
setEnabled(enabled: boolean) {
setEnabled (enabled: boolean) {
if (enabled) this.switch.classList.add("active");
else this.switch.classList.remove("active");
this.enabled = enabled;
}
isEnabled(): boolean {
isEnabled (): boolean {
return this.enabled;
}
}
@ -1106,9 +1106,9 @@ class Slider {
private knob: HTMLElement;
public change: (percentage: number) => void;
constructor(public snaps = 0, public snapPercentage = 0.1, public big = false) { }
constructor (public snaps = 0, public snapPercentage = 0.1, public big = false) { }
create(): HTMLElement {
create (): HTMLElement {
this.slider = createElement(/*html*/`
<div class="spine-player-slider ${this.big ? "big" : ""}">
<div class="spine-player-slider-value"></div>
@ -1140,7 +1140,7 @@ class Slider {
return this.slider;
}
setValue(percentage: number): number {
setValue (percentage: number): number {
percentage = Math.max(0, Math.min(1, percentage));
if (this.snaps) {
let snap = 1 / this.snaps;
@ -1158,22 +1158,22 @@ class Slider {
}
}
function findWithClass(element: HTMLElement, className: string): HTMLElement {
function findWithClass (element: HTMLElement, className: string): HTMLElement {
return element.getElementsByClassName(className)[0] as HTMLElement;
}
function createElement(html: string): HTMLElement {
function createElement (html: string): HTMLElement {
let div = document.createElement("div");
div.innerHTML = html;
return div.children[0] as HTMLElement;
}
function removeClass(elements: HTMLCollection, clazz: string) {
function removeClass (elements: HTMLCollection, clazz: string) {
for (let i = 0; i < elements.length; i++)
elements[i].classList.remove(clazz);
}
function toString(object: any) {
function toString (object: any) {
return JSON.stringify(object)
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")

12
spine-ts/spine-player/src/PlayerEditor.ts
View File

@ -27,7 +27,7 @@
* THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*****************************************************************************/
declare function CodeMirror(el: Element, config: any): void;
declare function CodeMirror (el: Element, config: any): void;
export class SpinePlayerEditor {
private static DEFAULT_CODE =
@ -57,11 +57,11 @@ body { margin: 0px; }
private code: any;
private player: HTMLIFrameElement;
constructor(parent: HTMLElement) {
constructor (parent: HTMLElement) {
this.render(parent);
}
private render(parent: HTMLElement) {
private render (parent: HTMLElement) {
let dom = /*html*/`
<div class="spine-player-editor-container">
<div class="spine-player-editor-code"></div>
@ -90,19 +90,19 @@ body { margin: 0px; }
})
}
setPreAndPostfix(prefix: string, postfix: string) {
setPreAndPostfix (prefix: string, postfix: string) {
this.prefix = prefix;
this.postfix = postfix;
this.startPlayer()
}
setCode(code: string) {
setCode (code: string) {
this.code.setValue(code);
this.startPlayer();
}
private timerId = 0;
startPlayer() {
startPlayer () {
clearTimeout(this.timerId);
this.timerId = setTimeout(() => {
let code = this.code.getDoc().getValue();

2
spine-ts/spine-threejs/src/AssetManager.ts
View File

@ -31,7 +31,7 @@ import { AssetManagerBase, Downloader } from "@esotericsoftware/spine-core"
import { ThreeJsTexture } from "./ThreeJsTexture";
export class AssetManager extends AssetManagerBase {
constructor(pathPrefix: string = "", downloader: Downloader = null) {
constructor (pathPrefix: string = "", downloader: Downloader = null) {
super((image: HTMLImageElement) => {
return new ThreeJsTexture(image);
}, pathPrefix, downloader);

14
spine-ts/spine-threejs/src/MeshBatcher.ts
View File

@ -38,7 +38,7 @@ export class MeshBatcher extends THREE.Mesh {
private indices: Uint16Array;
private indicesLength = 0;
constructor(maxVertices: number = 10920, materialCustomizer: SkeletonMeshMaterialParametersCustomizer = (parameters) => { }) {
constructor (maxVertices: number = 10920, materialCustomizer: SkeletonMeshMaterialParametersCustomizer = (parameters) => { }) {
super();
if (maxVertices > 10920) throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices);
let vertices = this.vertices = new Float32Array(maxVertices * MeshBatcher.VERTEX_SIZE);
@ -57,7 +57,7 @@ export class MeshBatcher extends THREE.Mesh {
this.material = new SkeletonMeshMaterial(materialCustomizer);
}
dispose() {
dispose () {
this.geometry.dispose();
if (this.material instanceof THREE.Material)
this.material.dispose();
@ -70,7 +70,7 @@ export class MeshBatcher extends THREE.Mesh {
}
}
clear() {
clear () {
let geo = (<THREE.BufferGeometry>this.geometry);
geo.drawRange.start = 0;
geo.drawRange.count = 0;
@ -78,18 +78,18 @@ export class MeshBatcher extends THREE.Mesh {
return this;
}
begin() {
begin () {
this.verticesLength = 0;
this.indicesLength = 0;
}
canBatch(verticesLength: number, indicesLength: number) {
canBatch (verticesLength: number, indicesLength: number) {
if (this.indicesLength + indicesLength >= this.indices.byteLength / 2) return false;
if (this.verticesLength + verticesLength >= this.vertices.byteLength / 2) return false;
return true;
}
batch(vertices: ArrayLike<number>, verticesLength: number, indices: ArrayLike<number>, indicesLength: number, z: number = 0) {
batch (vertices: ArrayLike<number>, verticesLength: number, indices: ArrayLike<number>, indicesLength: number, z: number = 0) {
let indexStart = this.verticesLength / MeshBatcher.VERTEX_SIZE;
let vertexBuffer = this.vertices;
let i = this.verticesLength;
@ -113,7 +113,7 @@ export class MeshBatcher extends THREE.Mesh {
this.indicesLength += indicesLength;
}
end() {
end () {
this.vertexBuffer.needsUpdate = this.verticesLength > 0;
this.vertexBuffer.updateRange.offset = 0;
this.vertexBuffer.updateRange.count = this.verticesLength;

14
spine-ts/spine-threejs/src/SkeletonMesh.ts
View File

@ -37,7 +37,7 @@ export interface SkeletonMeshMaterialParametersCustomizer {
}
export class SkeletonMeshMaterial extends THREE.ShaderMaterial {
constructor(customizer: SkeletonMeshMaterialParametersCustomizer) {
constructor (customizer: SkeletonMeshMaterialParametersCustomizer) {
let vertexShader = `
attribute vec4 color;
varying vec2 vUv;
@ -93,7 +93,7 @@ export class SkeletonMesh extends THREE.Object3D {
private tempColor = new Color();
private materialCustomizer: SkeletonMeshMaterialParametersCustomizer;
constructor(skeletonData: SkeletonData, materialCustomizer: SkeletonMeshMaterialParametersCustomizer = (parameters) => { }) {
constructor (skeletonData: SkeletonData, materialCustomizer: SkeletonMeshMaterialParametersCustomizer = (parameters) => { }) {
super();
this.materialCustomizer = materialCustomizer;
this.skeleton = new Skeleton(skeletonData);
@ -101,7 +101,7 @@ export class SkeletonMesh extends THREE.Object3D {
this.state = new AnimationState(animData);
}
update(deltaTime: number) {
update (deltaTime: number) {
let state = this.state;
let skeleton = this.skeleton;
@ -112,13 +112,13 @@ export class SkeletonMesh extends THREE.Object3D {
this.updateGeometry();
}
dispose() {
dispose () {
for (var i = 0; i < this.batches.length; i++) {
this.batches[i].dispose();
}
}
private clearBatches() {
private clearBatches () {
for (var i = 0; i < this.batches.length; i++) {
this.batches[i].clear();
this.batches[i].visible = false;
@ -126,7 +126,7 @@ export class SkeletonMesh extends THREE.Object3D {
this.nextBatchIndex = 0;
}
private nextBatch() {
private nextBatch () {
if (this.batches.length == this.nextBatchIndex) {
let batch = new MeshBatcher(10920, this.materialCustomizer);
this.add(batch);
@ -137,7 +137,7 @@ export class SkeletonMesh extends THREE.Object3D {
return batch;
}
private updateGeometry() {
private updateGeometry () {
this.clearBatches();
let tempPos = this.tempPos;

12
spine-ts/spine-threejs/src/ThreeJsTexture.ts
View File

@ -33,28 +33,28 @@ import * as THREE from "three";
export class ThreeJsTexture extends Texture {
texture: THREE.Texture;
constructor(image: HTMLImageElement) {
constructor (image: HTMLImageElement) {
super(image);
this.texture = new THREE.Texture(image);
this.texture.flipY = false;
this.texture.needsUpdate = true;
}
setFilters(minFilter: TextureFilter, magFilter: TextureFilter) {
setFilters (minFilter: TextureFilter, magFilter: TextureFilter) {
this.texture.minFilter = ThreeJsTexture.toThreeJsTextureFilter(minFilter);
this.texture.magFilter = ThreeJsTexture.toThreeJsTextureFilter(magFilter);
}
setWraps(uWrap: TextureWrap, vWrap: TextureWrap) {
setWraps (uWrap: TextureWrap, vWrap: TextureWrap) {
this.texture.wrapS = ThreeJsTexture.toThreeJsTextureWrap(uWrap);
this.texture.wrapT = ThreeJsTexture.toThreeJsTextureWrap(vWrap);
}
dispose() {
dispose () {
this.texture.dispose();
}
static toThreeJsTextureFilter(filter: TextureFilter) {
static toThreeJsTextureFilter (filter: TextureFilter) {
if (filter === TextureFilter.Linear) return THREE.LinearFilter;
else if (filter === TextureFilter.MipMap) return THREE.LinearMipMapLinearFilter; // also includes TextureFilter.MipMapLinearLinear
else if (filter === TextureFilter.MipMapLinearNearest) return THREE.LinearMipMapNearestFilter;
@ -64,7 +64,7 @@ export class ThreeJsTexture extends Texture {
else throw new Error("Unknown texture filter: " + filter);
}
static toThreeJsTextureWrap(wrap: TextureWrap) {
static toThreeJsTextureWrap (wrap: TextureWrap) {
if (wrap === TextureWrap.ClampToEdge) return THREE.ClampToEdgeWrapping;
else if (wrap === TextureWrap.MirroredRepeat) return THREE.MirroredRepeatWrapping;
else if (wrap === TextureWrap.Repeat) return THREE.RepeatWrapping;

2
spine-ts/spine-webgl/src/AssetManager.ts
View File

@ -33,7 +33,7 @@ import { GLTexture } from "./GLTexture";
export class AssetManager extends AssetManagerBase {
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix: string = "", downloader: Downloader = null) {
constructor (context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix: string = "", downloader: Downloader = null) {
super((image: HTMLImageElement | ImageBitmap) => {
return new GLTexture(context, image);
}, pathPrefix, downloader);

10
spine-ts/spine-webgl/src/Camera.ts
View File

@ -44,13 +44,13 @@ export class OrthoCamera {
projection = new Matrix4();
view = new Matrix4();
constructor(viewportWidth: number, viewportHeight: number) {
constructor (viewportWidth: number, viewportHeight: number) {
this.viewportWidth = viewportWidth;
this.viewportHeight = viewportHeight;
this.update();
}
update() {
update () {
let projection = this.projection;
let view = this.view;
let projectionView = this.projectionView;
@ -65,7 +65,7 @@ export class OrthoCamera {
inverseProjectionView.set(projectionView.values).invert();
}
screenToWorld(screenCoords: Vector3, screenWidth: number, screenHeight: number) {
screenToWorld (screenCoords: Vector3, screenWidth: number, screenHeight: number) {
let x = screenCoords.x, y = screenHeight - screenCoords.y - 1;
screenCoords.x = (2 * x) / screenWidth - 1;
screenCoords.y = (2 * y) / screenHeight - 1;
@ -74,7 +74,7 @@ export class OrthoCamera {
return screenCoords;
}
worldToScreen(worldCoords: Vector3, screenWidth: number, screenHeight: number) {
worldToScreen (worldCoords: Vector3, screenWidth: number, screenHeight: number) {
worldCoords.project(this.projectionView);
worldCoords.x = screenWidth * (worldCoords.x + 1) / 2;
worldCoords.y = screenHeight * (worldCoords.y + 1) / 2;
@ -82,7 +82,7 @@ export class OrthoCamera {
return worldCoords;
}
setViewport(viewportWidth: number, viewportHeight: number) {
setViewport (viewportWidth: number, viewportHeight: number) {
this.viewportWidth = viewportWidth;
this.viewportHeight = viewportHeight;
}

18
spine-ts/spine-webgl/src/GLTexture.ts
View File

@ -38,7 +38,7 @@ export class GLTexture extends Texture implements Disposable, Restorable {
public static DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL = false;
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement | ImageBitmap, useMipMaps: boolean = false) {
constructor (context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement | ImageBitmap, useMipMaps: boolean = false) {
super(image);
this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
this.useMipMaps = useMipMaps;
@ -46,14 +46,14 @@ export class GLTexture extends Texture implements Disposable, Restorable {
this.context.addRestorable(this);
}
setFilters(minFilter: TextureFilter, magFilter: TextureFilter) {
setFilters (minFilter: TextureFilter, magFilter: TextureFilter) {
let gl = this.context.gl;
this.bind();
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, GLTexture.validateMagFilter(magFilter));
}
static validateMagFilter(magFilter: TextureFilter) {
static validateMagFilter (magFilter: TextureFilter) {
switch (magFilter) {
case TextureFilter.MipMap:
case TextureFilter.MipMapLinearLinear:
@ -66,14 +66,14 @@ export class GLTexture extends Texture implements Disposable, Restorable {
}
}
setWraps(uWrap: TextureWrap, vWrap: TextureWrap) {
setWraps (uWrap: TextureWrap, vWrap: TextureWrap) {
let gl = this.context.gl;
this.bind();
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, uWrap);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, vWrap);
}
update(useMipMaps: boolean) {
update (useMipMaps: boolean) {
let gl = this.context.gl;
if (!this.texture) this.texture = this.context.gl.createTexture();
this.bind();
@ -86,25 +86,25 @@ export class GLTexture extends Texture implements Disposable, Restorable {
if (useMipMaps) gl.generateMipmap(gl.TEXTURE_2D);
}
restore() {
restore () {
this.texture = null;
this.update(this.useMipMaps);
}
bind(unit: number = 0) {
bind (unit: number = 0) {
let gl = this.context.gl;
this.boundUnit = unit;
gl.activeTexture(gl.TEXTURE0 + unit);
gl.bindTexture(gl.TEXTURE_2D, this.texture);
}
unbind() {
unbind () {
let gl = this.context.gl;
gl.activeTexture(gl.TEXTURE0 + this.boundUnit);
gl.bindTexture(gl.TEXTURE_2D, null);
}
dispose() {
dispose () {
this.context.removeRestorable(this);
let gl = this.context.gl;
gl.deleteTexture(this.texture);

18
spine-ts/spine-webgl/src/Input.ts
View File

@ -41,12 +41,12 @@ export class Input {
return new Touch(0, 0, 0);
});
constructor(element: HTMLElement) {
constructor (element: HTMLElement) {
this.element = element;
this.setupCallbacks(element);
}
private setupCallbacks(element: HTMLElement) {
private setupCallbacks (element: HTMLElement) {
let mouseDown = (ev: UIEvent) => {
if (ev instanceof MouseEvent) {
let rect = element.getBoundingClientRect();
@ -208,11 +208,11 @@ export class Input {
}, false);
}
addListener(listener: InputListener) {
addListener (listener: InputListener) {
this.listeners.push(listener);
}
removeListener(listener: InputListener) {
removeListener (listener: InputListener) {
let idx = this.listeners.indexOf(listener);
if (idx > -1) {
this.listeners.splice(idx, 1);
@ -221,13 +221,13 @@ export class Input {
}
export class Touch {
constructor(public identifier: number, public x: number, public y: number) {
constructor (public identifier: number, public x: number, public y: number) {
}
}
export 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;
down (x: number, y: number): void;
up (x: number, y: number): void;
moved (x: number, y: number): void;
dragged (x: number, y: number): void;
}

4
spine-ts/spine-webgl/src/LoadingScreen.ts
View File

@ -49,7 +49,7 @@ export class LoadingScreen {
backgroundColor = new Color(0.135, 0.135, 0.135, 1);
private tempColor = new Color();
constructor(renderer: SceneRenderer) {
constructor (renderer: SceneRenderer) {
this.renderer = renderer;
this.timeKeeper.maxDelta = 9;
@ -70,7 +70,7 @@ export class LoadingScreen {
}
}
draw(complete = false) {
draw (complete = false) {
if (loaded < 2 || (complete && this.fadeOut > FADE_OUT)) return;
this.timeKeeper.update();

30
spine-ts/spine-webgl/src/Matrix4.ts
View File

@ -55,7 +55,7 @@ export class Matrix4 {
private static zAxis: Vector3 = null;
private static tmpMatrix = new Matrix4();
constructor() {
constructor () {
let v = this.values;
v[M00] = 1;
v[M11] = 1;
@ -63,12 +63,12 @@ export class Matrix4 {
v[M33] = 1;
}
set(values: ArrayLike<number>): Matrix4 {
set (values: ArrayLike<number>): Matrix4 {
this.values.set(values);
return this;
}
transpose(): Matrix4 {
transpose (): Matrix4 {
let t = this.temp;
let v = this.values;
t[M00] = v[M00];
@ -90,7 +90,7 @@ export class Matrix4 {
return this.set(t);
}
identity(): Matrix4 {
identity (): Matrix4 {
let v = this.values;
v[M00] = 1;
v[M01] = 0;
@ -111,7 +111,7 @@ export class Matrix4 {
return this;
}
invert(): Matrix4 {
invert (): Matrix4 {
let v = this.values;
let t = this.temp;
let l_det = v[M30] * v[M21] * v[M12] * v[M03] - v[M20] * v[M31] * v[M12] * v[M03] - v[M30] * v[M11] * v[M22] * v[M03]
@ -175,7 +175,7 @@ export class Matrix4 {
return this;
}
determinant(): number {
determinant (): number {
let v = this.values;
return v[M30] * v[M21] * v[M12] * v[M03] - v[M20] * v[M31] * v[M12] * v[M03] - v[M30] * v[M11] * v[M22] * v[M03]
+ v[M10] * v[M31] * v[M22] * v[M03] + v[M20] * v[M11] * v[M32] * v[M03] - v[M10] * v[M21] * v[M32] * v[M03]
@ -187,7 +187,7 @@ export class Matrix4 {
- v[M00] * v[M21] * v[M12] * v[M33] - v[M10] * v[M01] * v[M22] * v[M33] + v[M00] * v[M11] * v[M22] * v[M33];
}
translate(x: number, y: number, z: number): Matrix4 {
translate (x: number, y: number, z: number): Matrix4 {
let v = this.values;
v[M03] += x;
v[M13] += y;
@ -195,11 +195,11 @@ export class Matrix4 {
return this;
}
copy(): Matrix4 {
copy (): Matrix4 {
return new Matrix4().set(this.values);
}
projection(near: number, far: number, fovy: number, aspectRatio: number): Matrix4 {
projection (near: number, far: number, fovy: number, aspectRatio: number): Matrix4 {
this.identity();
let l_fd = (1.0 / Math.tan((fovy * (Math.PI / 180)) / 2.0));
let l_a1 = (far + near) / (near - far);
@ -224,11 +224,11 @@ export class Matrix4 {
return this;
}
ortho2d(x: number, y: number, width: number, height: number): Matrix4 {
ortho2d (x: number, y: number, width: number, height: number): Matrix4 {
return this.ortho(x, x + width, y, y + height, 0, 1);
}
ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4 {
ortho (left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4 {
this.identity();
let x_orth = 2 / (right - left);
let y_orth = 2 / (top - bottom);
@ -258,7 +258,7 @@ export class Matrix4 {
return this;
}
multiply(matrix: Matrix4): Matrix4 {
multiply (matrix: Matrix4): Matrix4 {
let t = this.temp;
let v = this.values;
let m = matrix.values;
@ -281,7 +281,7 @@ export class Matrix4 {
return this.set(this.temp);
}
multiplyLeft(matrix: Matrix4): Matrix4 {
multiplyLeft (matrix: Matrix4): Matrix4 {
let t = this.temp;
let v = this.values;
let m = matrix.values;
@ -304,7 +304,7 @@ export class Matrix4 {
return this.set(this.temp);
}
lookAt(position: Vector3, direction: Vector3, up: Vector3) {
lookAt (position: Vector3, direction: Vector3, up: Vector3) {
Matrix4.initTemps();
let xAxis = Matrix4.xAxis, yAxis = Matrix4.yAxis, zAxis = Matrix4.zAxis;
zAxis.setFrom(direction).normalize();
@ -332,7 +332,7 @@ export class Matrix4 {
return this;
}
static initTemps() {
static initTemps () {
if (Matrix4.xAxis === null) Matrix4.xAxis = new Vector3();
if (Matrix4.yAxis === null) Matrix4.yAxis = new Vector3();
if (Matrix4.zAxis === null) Matrix4.zAxis = new Vector3();

52
spine-ts/spine-webgl/src/Mesh.ts
View File

@ -44,25 +44,25 @@ export class Mesh implements Disposable, Restorable {
private dirtyIndices = false;
private elementsPerVertex = 0;
getAttributes(): VertexAttribute[] { return this.attributes; }
getAttributes (): VertexAttribute[] { return this.attributes; }
maxVertices(): number { return this.vertices.length / this.elementsPerVertex; }
numVertices(): number { return this.verticesLength / this.elementsPerVertex; }
setVerticesLength(length: number) {
maxVertices (): number { return this.vertices.length / this.elementsPerVertex; }
numVertices (): number { return this.verticesLength / this.elementsPerVertex; }
setVerticesLength (length: number) {
this.dirtyVertices = true;
this.verticesLength = length;
}
getVertices(): Float32Array { return this.vertices; }
getVertices (): Float32Array { return this.vertices; }
maxIndices(): number { return this.indices.length; }
numIndices(): number { return this.indicesLength; }
setIndicesLength(length: number) {
maxIndices (): number { return this.indices.length; }
numIndices (): number { return this.indicesLength; }
setIndicesLength (length: number) {
this.dirtyIndices = true;
this.indicesLength = length;
}
getIndices(): Uint16Array { return this.indices };
getIndices (): Uint16Array { return this.indices };
getVertexSizeInFloats(): number {
getVertexSizeInFloats (): number {
let size = 0;
for (var i = 0; i < this.attributes.length; i++) {
let attribute = this.attributes[i];
@ -71,7 +71,7 @@ export class Mesh implements Disposable, Restorable {
return size;
}
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, private attributes: VertexAttribute[], maxVertices: number, maxIndices: number) {
constructor (context: ManagedWebGLRenderingContext | WebGLRenderingContext, private attributes: VertexAttribute[], maxVertices: number, maxIndices: number) {
this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
this.elementsPerVertex = 0;
for (let i = 0; i < attributes.length; i++) {
@ -82,25 +82,25 @@ export class Mesh implements Disposable, Restorable {
this.context.addRestorable(this);
}
setVertices(vertices: Array<number>) {
setVertices (vertices: Array<number>) {
this.dirtyVertices = true;
if (vertices.length > this.vertices.length) throw Error("Mesh can't store more than " + this.maxVertices() + " vertices");
this.vertices.set(vertices, 0);
this.verticesLength = vertices.length;
}
setIndices(indices: Array<number>) {
setIndices (indices: Array<number>) {
this.dirtyIndices = true;
if (indices.length > this.indices.length) throw Error("Mesh can't store more than " + this.maxIndices() + " indices");
this.indices.set(indices, 0);
this.indicesLength = indices.length;
}
draw(shader: Shader, primitiveType: number) {
draw (shader: Shader, primitiveType: number) {
this.drawWithOffset(shader, primitiveType, 0, this.indicesLength > 0 ? this.indicesLength : this.verticesLength / this.elementsPerVertex);
}
drawWithOffset(shader: Shader, primitiveType: number, offset: number, count: number) {
drawWithOffset (shader: Shader, primitiveType: number, offset: number, count: number) {
let gl = this.context.gl;
if (this.dirtyVertices || this.dirtyIndices) this.update();
this.bind(shader);
@ -112,7 +112,7 @@ export class Mesh implements Disposable, Restorable {
this.unbind(shader);
}
bind(shader: Shader) {
bind (shader: Shader) {
let gl = this.context.gl;
gl.bindBuffer(gl.ARRAY_BUFFER, this.verticesBuffer);
let offset = 0;
@ -126,7 +126,7 @@ export class Mesh implements Disposable, Restorable {
if (this.indicesLength > 0) gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indicesBuffer);
}
unbind(shader: Shader) {
unbind (shader: Shader) {
let gl = this.context.gl;
for (let i = 0; i < this.attributes.length; i++) {
let attrib = this.attributes[i];
@ -137,7 +137,7 @@ export class Mesh implements Disposable, Restorable {
if (this.indicesLength > 0) gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
}
private update() {
private update () {
let gl = this.context.gl;
if (this.dirtyVertices) {
if (!this.verticesBuffer) {
@ -158,13 +158,13 @@ export class Mesh implements Disposable, Restorable {
}
}
restore() {
restore () {
this.verticesBuffer = null;
this.indicesBuffer = null;
this.update();
}
dispose() {
dispose () {
this.context.removeRestorable(this);
let gl = this.context.gl;
gl.deleteBuffer(this.verticesBuffer);
@ -173,35 +173,35 @@ export class Mesh implements Disposable, Restorable {
}
export class VertexAttribute {
constructor(public name: string, public type: VertexAttributeType, public numElements: number) { }
constructor (public name: string, public type: VertexAttributeType, public numElements: number) { }
}
export class Position2Attribute extends VertexAttribute {
constructor() {
constructor () {
super(Shader.POSITION, VertexAttributeType.Float, 2);
}
}
export class Position3Attribute extends VertexAttribute {
constructor() {
constructor () {
super(Shader.POSITION, VertexAttributeType.Float, 3);
}
}
export class TexCoordAttribute extends VertexAttribute {
constructor(unit: number = 0) {
constructor (unit: number = 0) {
super(Shader.TEXCOORDS + (unit == 0 ? "" : unit), VertexAttributeType.Float, 2);
}
}
export class ColorAttribute extends VertexAttribute {
constructor() {
constructor () {
super(Shader.COLOR, VertexAttributeType.Float, 4);
}
}
export class Color2Attribute extends VertexAttribute {
constructor() {
constructor () {
super(Shader.COLOR2, VertexAttributeType.Float, 4);
}
}

16
spine-ts/spine-webgl/src/PolygonBatcher.ts
View File

@ -46,7 +46,7 @@ export class PolygonBatcher implements Disposable {
private srcAlphaBlend: number;
private dstBlend: number;
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint: boolean = true, maxVertices: number = 10920) {
constructor (context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint: boolean = true, maxVertices: number = 10920) {
if (maxVertices > 10920) throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices);
this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
let attributes = twoColorTint ?
@ -59,7 +59,7 @@ export class PolygonBatcher implements Disposable {
this.dstBlend = gl.ONE_MINUS_SRC_ALPHA;
}
begin(shader: Shader) {
begin (shader: Shader) {
if (this.isDrawing) throw new Error("PolygonBatch is already drawing. Call PolygonBatch.end() before calling PolygonBatch.begin()");
this.drawCalls = 0;
this.shader = shader;
@ -71,7 +71,7 @@ export class PolygonBatcher implements Disposable {
gl.blendFuncSeparate(this.srcColorBlend, this.dstBlend, this.srcAlphaBlend, this.dstBlend);
}
setBlendMode(srcColorBlend: number, srcAlphaBlend: number, dstBlend: number) {
setBlendMode (srcColorBlend: number, srcAlphaBlend: number, dstBlend: number) {
this.srcColorBlend = srcColorBlend;
this.srcAlphaBlend = srcAlphaBlend;
this.dstBlend = dstBlend;
@ -82,7 +82,7 @@ export class PolygonBatcher implements Disposable {
}
}
draw(texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>) {
draw (texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>) {
if (texture != this.lastTexture) {
this.flush();
this.lastTexture = texture;
@ -103,7 +103,7 @@ export class PolygonBatcher implements Disposable {
this.mesh.setIndicesLength(this.indicesLength);
}
flush() {
flush () {
if (this.verticesLength == 0) return;
this.lastTexture.bind();
@ -116,7 +116,7 @@ export class PolygonBatcher implements Disposable {
this.drawCalls++;
}
end() {
end () {
if (!this.isDrawing) throw new Error("PolygonBatch is not drawing. Call PolygonBatch.begin() before calling PolygonBatch.end()");
if (this.verticesLength > 0 || this.indicesLength > 0) this.flush();
this.shader = null;
@ -127,11 +127,11 @@ export class PolygonBatcher implements Disposable {
gl.disable(gl.BLEND);
}
getDrawCalls() {
getDrawCalls () {
return this.drawCalls;
}
dispose() {
dispose () {
this.mesh.dispose();
}
}

40
spine-ts/spine-webgl/src/SceneRenderer.ts
View File

@ -60,7 +60,7 @@ export class SceneRenderer implements Disposable {
skeletonRenderer: SkeletonRenderer;
skeletonDebugRenderer: SkeletonDebugRenderer;
constructor(canvas: HTMLCanvasElement, context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint: boolean = true) {
constructor (canvas: HTMLCanvasElement, context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint: boolean = true) {
this.canvas = canvas;
this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
this.twoColorTint = twoColorTint;
@ -73,24 +73,24 @@ export class SceneRenderer implements Disposable {
this.skeletonDebugRenderer = new SkeletonDebugRenderer(this.context);
}
begin() {
begin () {
this.camera.update();
this.enableRenderer(this.batcher);
}
drawSkeleton(skeleton: Skeleton, premultipliedAlpha = false, slotRangeStart = -1, slotRangeEnd = -1) {
drawSkeleton (skeleton: Skeleton, premultipliedAlpha = false, slotRangeStart = -1, slotRangeEnd = -1) {
this.enableRenderer(this.batcher);
this.skeletonRenderer.premultipliedAlpha = premultipliedAlpha;
this.skeletonRenderer.draw(this.batcher, skeleton, slotRangeStart, slotRangeEnd);
}
drawSkeletonDebug(skeleton: Skeleton, premultipliedAlpha = false, ignoredBones: Array<string> = null) {
drawSkeletonDebug (skeleton: Skeleton, premultipliedAlpha = false, ignoredBones: Array<string> = null) {
this.enableRenderer(this.shapes);
this.skeletonDebugRenderer.premultipliedAlpha = premultipliedAlpha;
this.skeletonDebugRenderer.draw(this.shapes, skeleton, ignoredBones);
}
drawTexture(texture: GLTexture, x: number, y: number, width: number, height: number, color: Color = null) {
drawTexture (texture: GLTexture, x: number, y: number, width: number, height: number, color: Color = null) {
this.enableRenderer(this.batcher);
if (color === null) color = WHITE;
var i = 0;
@ -153,7 +153,7 @@ export class SceneRenderer implements Disposable {
this.batcher.draw(texture, quad, QUAD_TRIANGLES);
}
drawTextureUV(texture: GLTexture, x: number, y: number, width: number, height: number, u: number, v: number, u2: number, v2: number, color: Color = null) {
drawTextureUV (texture: GLTexture, x: number, y: number, width: number, height: number, u: number, v: number, u2: number, v2: number, color: Color = null) {
this.enableRenderer(this.batcher);
if (color === null) color = WHITE;
var i = 0;
@ -216,7 +216,7 @@ export class SceneRenderer implements Disposable {
this.batcher.draw(texture, quad, QUAD_TRIANGLES);
}
drawTextureRotated(texture: GLTexture, x: number, y: number, width: number, height: number, pivotX: number, pivotY: number, angle: number, color: Color = null) {
drawTextureRotated (texture: GLTexture, x: number, y: number, width: number, height: number, pivotX: number, pivotY: number, angle: number, color: Color = null) {
this.enableRenderer(this.batcher);
if (color === null) color = WHITE;
@ -346,7 +346,7 @@ export class SceneRenderer implements Disposable {
this.batcher.draw(texture, quad, QUAD_TRIANGLES);
}
drawRegion(region: TextureAtlasRegion, x: number, y: number, width: number, height: number, color: Color = null) {
drawRegion (region: TextureAtlasRegion, x: number, y: number, width: number, height: number, color: Color = null) {
this.enableRenderer(this.batcher);
if (color === null) color = WHITE;
var i = 0;
@ -409,53 +409,53 @@ export class SceneRenderer implements Disposable {
this.batcher.draw(<GLTexture>region.page.texture, quad, QUAD_TRIANGLES);
}
line(x: number, y: number, x2: number, y2: number, color: Color = null, color2: Color = null) {
line (x: number, y: number, x2: number, y2: number, color: Color = null, color2: Color = null) {
this.enableRenderer(this.shapes);
this.shapes.line(x, y, x2, y2, color);
}
triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color: Color = null, color2: Color = null, color3: Color = null) {
triangle (filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color: Color = null, color2: Color = null, color3: Color = null) {
this.enableRenderer(this.shapes);
this.shapes.triangle(filled, x, y, x2, y2, x3, y3, color, color2, color3);
}
quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color: Color = null, color2: Color = null, color3: Color = null, color4: Color = null) {
quad (filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color: Color = null, color2: Color = null, color3: Color = null, color4: Color = null) {
this.enableRenderer(this.shapes);
this.shapes.quad(filled, x, y, x2, y2, x3, y3, x4, y4, color, color2, color3, color4);
}
rect(filled: boolean, x: number, y: number, width: number, height: number, color: Color = null) {
rect (filled: boolean, x: number, y: number, width: number, height: number, color: Color = null) {
this.enableRenderer(this.shapes);
this.shapes.rect(filled, x, y, width, height, color);
}
rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color: Color = null) {
rectLine (filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color: Color = null) {
this.enableRenderer(this.shapes);
this.shapes.rectLine(filled, x1, y1, x2, y2, width, color);
}
polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color: Color = null) {
polygon (polygonVertices: ArrayLike<number>, offset: number, count: number, color: Color = null) {
this.enableRenderer(this.shapes);
this.shapes.polygon(polygonVertices, offset, count, color);
}
circle(filled: boolean, x: number, y: number, radius: number, color: Color = null, segments: number = 0) {
circle (filled: boolean, x: number, y: number, radius: number, color: Color = null, segments: number = 0) {
this.enableRenderer(this.shapes);
this.shapes.circle(filled, x, y, radius, color, segments);
}
curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color: Color = null) {
curve (x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color: Color = null) {
this.enableRenderer(this.shapes);
this.shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, segments, color);
}
end() {
end () {
if (this.activeRenderer === this.batcher) this.batcher.end();
else if (this.activeRenderer === this.shapes) this.shapes.end();
this.activeRenderer = null;
}
resize(resizeMode: ResizeMode) {
resize (resizeMode: ResizeMode) {
let canvas = this.canvas;
var dpr = window.devicePixelRatio || 1;
var w = Math.round(canvas.clientWidth * dpr);
@ -481,7 +481,7 @@ export class SceneRenderer implements Disposable {
this.camera.update();
}
private enableRenderer(renderer: PolygonBatcher | ShapeRenderer | SkeletonDebugRenderer) {
private enableRenderer (renderer: PolygonBatcher | ShapeRenderer | SkeletonDebugRenderer) {
if (this.activeRenderer === renderer) return;
this.end();
if (renderer instanceof PolygonBatcher) {
@ -499,7 +499,7 @@ export class SceneRenderer implements Disposable {
this.activeRenderer = this.skeletonDebugRenderer;
}
dispose() {
dispose () {
this.batcher.dispose();
this.batcherShader.dispose();
this.shapes.dispose();

52
spine-ts/spine-webgl/src/Shader.ts
View File

@ -48,13 +48,13 @@ export class Shader implements Disposable, Restorable {
private tmp3x3: Float32Array = new Float32Array(3 * 3);
private tmp4x4: Float32Array = new Float32Array(4 * 4);
public getProgram() { return this.program; }
public getVertexShader() { return this.vertexShader; }
public getFragmentShader() { return this.fragmentShader; }
public getVertexShaderSource() { return this.vsSource; }
public getFragmentSource() { return this.fsSource; }
public getProgram () { return this.program; }
public getVertexShader () { return this.vertexShader; }
public getFragmentShader () { return this.fragmentShader; }
public getVertexShaderSource () { return this.vsSource; }
public getFragmentSource () { return this.fsSource; }
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, private vertexShader: string, private fragmentShader: string) {
constructor (context: ManagedWebGLRenderingContext | WebGLRenderingContext, private vertexShader: string, private fragmentShader: string) {
this.vsSource = vertexShader;
this.fsSource = fragmentShader;
this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
@ -62,7 +62,7 @@ export class Shader implements Disposable, Restorable {
this.compile();
}
private compile() {
private compile () {
let gl = this.context.gl;
try {
this.vs = this.compileShader(gl.VERTEX_SHADER, this.vertexShader);
@ -74,7 +74,7 @@ export class Shader implements Disposable, Restorable {
}
}
private compileShader(type: number, source: string) {
private compileShader (type: number, source: string) {
let gl = this.context.gl;
let shader = gl.createShader(type);
gl.shaderSource(shader, source);
@ -87,7 +87,7 @@ export class Shader implements Disposable, Restorable {
return shader;
}
private compileProgram(vs: WebGLShader, fs: WebGLShader) {
private compileProgram (vs: WebGLShader, fs: WebGLShader) {
let gl = this.context.gl;
let program = gl.createProgram();
gl.attachShader(program, vs);
@ -102,71 +102,71 @@ export class Shader implements Disposable, Restorable {
return program;
}
restore() {
restore () {
this.compile();
}
public bind() {
public bind () {
this.context.gl.useProgram(this.program);
}
public unbind() {
public unbind () {
this.context.gl.useProgram(null);
}
public setUniformi(uniform: string, value: number) {
public setUniformi (uniform: string, value: number) {
this.context.gl.uniform1i(this.getUniformLocation(uniform), value);
}
public setUniformf(uniform: string, value: number) {
public setUniformf (uniform: string, value: number) {
this.context.gl.uniform1f(this.getUniformLocation(uniform), value);
}
public setUniform2f(uniform: string, value: number, value2: number) {
public setUniform2f (uniform: string, value: number, value2: number) {
this.context.gl.uniform2f(this.getUniformLocation(uniform), value, value2);
}
public setUniform3f(uniform: string, value: number, value2: number, value3: number) {
public setUniform3f (uniform: string, value: number, value2: number, value3: number) {
this.context.gl.uniform3f(this.getUniformLocation(uniform), value, value2, value3);
}
public setUniform4f(uniform: string, value: number, value2: number, value3: number, value4: number) {
public setUniform4f (uniform: string, value: number, value2: number, value3: number, value4: number) {
this.context.gl.uniform4f(this.getUniformLocation(uniform), value, value2, value3, value4);
}
public setUniform2x2f(uniform: string, value: ArrayLike<number>) {
public setUniform2x2f (uniform: string, value: ArrayLike<number>) {
let gl = this.context.gl;
this.tmp2x2.set(value);
gl.uniformMatrix2fv(this.getUniformLocation(uniform), false, this.tmp2x2);
}
public setUniform3x3f(uniform: string, value: ArrayLike<number>) {
public setUniform3x3f (uniform: string, value: ArrayLike<number>) {
let gl = this.context.gl;
this.tmp3x3.set(value);
gl.uniformMatrix3fv(this.getUniformLocation(uniform), false, this.tmp3x3);
}
public setUniform4x4f(uniform: string, value: ArrayLike<number>) {
public setUniform4x4f (uniform: string, value: ArrayLike<number>) {
let gl = this.context.gl;
this.tmp4x4.set(value);
gl.uniformMatrix4fv(this.getUniformLocation(uniform), false, this.tmp4x4);
}
public getUniformLocation(uniform: string): WebGLUniformLocation {
public getUniformLocation (uniform: string): WebGLUniformLocation {
let gl = this.context.gl;
let location = gl.getUniformLocation(this.program, uniform);
if (!location && !gl.isContextLost()) throw new Error(`Couldn't find location for uniform ${uniform}`);
return location;
}
public getAttributeLocation(attribute: string): number {
public getAttributeLocation (attribute: string): number {
let gl = this.context.gl;
let location = gl.getAttribLocation(this.program, attribute);
if (location == -1 && !gl.isContextLost()) throw new Error(`Couldn't find location for attribute ${attribute}`);
return location;
}
public dispose() {
public dispose () {
this.context.removeRestorable(this);
let gl = this.context.gl;
@ -186,7 +186,7 @@ export class Shader implements Disposable, Restorable {
}
}
public static newColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
public static newColoredTextured (context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
let vs = `
attribute vec4 ${Shader.POSITION};
attribute vec4 ${Shader.COLOR};
@ -221,7 +221,7 @@ export class Shader implements Disposable, Restorable {
return new Shader(context, vs, fs);
}
public static newTwoColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
public static newTwoColoredTextured (context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
let vs = `
attribute vec4 ${Shader.POSITION};
attribute vec4 ${Shader.COLOR};
@ -262,7 +262,7 @@ export class Shader implements Disposable, Restorable {
return new Shader(context, vs, fs);
}
public static newColored(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
public static newColored (context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
let vs = `
attribute vec4 ${Shader.POSITION};
attribute vec4 ${Shader.COLOR};

40
spine-ts/spine-webgl/src/ShapeRenderer.ts
View File

@ -45,7 +45,7 @@ export class ShapeRenderer implements Disposable {
private srcAlphaBlend: number;
private dstBlend: number;
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices: number = 10920) {
constructor (context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices: number = 10920) {
if (maxVertices > 10920) throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices);
this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
this.mesh = new Mesh(context, [new Position2Attribute(), new ColorAttribute()], maxVertices, 0);
@ -55,7 +55,7 @@ export class ShapeRenderer implements Disposable {
this.dstBlend = gl.ONE_MINUS_SRC_ALPHA;
}
begin(shader: Shader) {
begin (shader: Shader) {
if (this.isDrawing) throw new Error("ShapeRenderer.begin() has already been called");
this.shader = shader;
this.vertexIndex = 0;
@ -66,7 +66,7 @@ export class ShapeRenderer implements Disposable {
gl.blendFuncSeparate(this.srcColorBlend, this.dstBlend, this.srcAlphaBlend, this.dstBlend);
}
setBlendMode(srcColorBlend: number, srcAlphaBlend: number, dstBlend: number) {
setBlendMode (srcColorBlend: number, srcAlphaBlend: number, dstBlend: number) {
this.srcColorBlend = srcColorBlend;
this.srcAlphaBlend = srcAlphaBlend;
this.dstBlend = dstBlend;
@ -77,21 +77,21 @@ export class ShapeRenderer implements Disposable {
}
}
setColor(color: Color) {
setColor (color: Color) {
this.color.setFromColor(color);
}
setColorWith(r: number, g: number, b: number, a: number) {
setColorWith (r: number, g: number, b: number, a: number) {
this.color.set(r, g, b, a);
}
point(x: number, y: number, color: Color = null) {
point (x: number, y: number, color: Color = null) {
this.check(ShapeType.Point, 1);
if (color === null) color = this.color;
this.vertex(x, y, color);
}
line(x: number, y: number, x2: number, y2: number, color: Color = null) {
line (x: number, y: number, x2: number, y2: number, color: Color = null) {
this.check(ShapeType.Line, 2);
let vertices = this.mesh.getVertices();
let idx = this.vertexIndex;
@ -100,7 +100,7 @@ export class ShapeRenderer implements Disposable {
this.vertex(x2, y2, color);
}
triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color: Color = null, color2: Color = null, color3: Color = null) {
triangle (filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color: Color = null, color2: Color = null, color3: Color = null) {
this.check(filled ? ShapeType.Filled : ShapeType.Line, 3);
let vertices = this.mesh.getVertices();
let idx = this.vertexIndex;
@ -123,7 +123,7 @@ export class ShapeRenderer implements Disposable {
}
}
quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color: Color = null, color2: Color = null, color3: Color = null, color4: Color = null) {
quad (filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color: Color = null, color2: Color = null, color3: Color = null, color4: Color = null) {
this.check(filled ? ShapeType.Filled : ShapeType.Line, 3);
let vertices = this.mesh.getVertices();
let idx = this.vertexIndex;
@ -142,11 +142,11 @@ export class ShapeRenderer implements Disposable {
}
}
rect(filled: boolean, x: number, y: number, width: number, height: number, color: Color = null) {
rect (filled: boolean, x: number, y: number, width: number, height: number, color: Color = null) {
this.quad(filled, x, y, x + width, y, x + width, y + height, x, y + height, color, color, color, color);
}
rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color: Color = null) {
rectLine (filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color: Color = null) {
this.check(filled ? ShapeType.Filled : ShapeType.Line, 8);
if (color === null) color = this.color;
let t = this.tmp.set(y2 - y1, x1 - x2);
@ -176,12 +176,12 @@ export class ShapeRenderer implements Disposable {
}
}
x(x: number, y: number, size: number) {
x (x: number, y: number, size: number) {
this.line(x - size, y - size, x + size, y + size);
this.line(x - size, y + size, x + size, y - size);
}
polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color: Color = null) {
polygon (polygonVertices: ArrayLike<number>, offset: number, count: number, color: Color = null) {
if (count < 3) throw new Error("Polygon must contain at least 3 vertices");
this.check(ShapeType.Line, count * 2);
if (color === null) color = this.color;
@ -215,7 +215,7 @@ export class ShapeRenderer implements Disposable {
}
}
circle(filled: boolean, x: number, y: number, radius: number, color: Color = null, segments: number = 0) {
circle (filled: boolean, x: number, y: number, radius: number, color: Color = null, segments: number = 0) {
if (segments === 0) segments = Math.max(1, (6 * MathUtils.cbrt(radius)) | 0);
if (segments <= 0) throw new Error("segments must be > 0.");
if (color === null) color = this.color;
@ -256,7 +256,7 @@ export class ShapeRenderer implements Disposable {
this.vertex(x + cx, y + cy, color);
}
curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color: Color = null) {
curve (x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color: Color = null) {
this.check(ShapeType.Line, segments * 2 + 2);
if (color === null) color = this.color;
@ -302,7 +302,7 @@ export class ShapeRenderer implements Disposable {
this.vertex(x2, y2, color);
}
private vertex(x: number, y: number, color: Color) {
private vertex (x: number, y: number, color: Color) {
let idx = this.vertexIndex;
let vertices = this.mesh.getVertices();
vertices[idx++] = x;
@ -314,7 +314,7 @@ export class ShapeRenderer implements Disposable {
this.vertexIndex = idx;
}
end() {
end () {
if (!this.isDrawing) throw new Error("ShapeRenderer.begin() has not been called");
this.flush();
let gl = this.context.gl;
@ -322,14 +322,14 @@ export class ShapeRenderer implements Disposable {
this.isDrawing = false;
}
private flush() {
private flush () {
if (this.vertexIndex == 0) return;
this.mesh.setVerticesLength(this.vertexIndex);
this.mesh.draw(this.shader, this.shapeType);
this.vertexIndex = 0;
}
private check(shapeType: ShapeType, numVertices: number) {
private check (shapeType: ShapeType, numVertices: number) {
if (!this.isDrawing) throw new Error("ShapeRenderer.begin() has not been called");
if (this.shapeType == shapeType) {
if (this.mesh.maxVertices() - this.mesh.numVertices() < numVertices) this.flush();
@ -340,7 +340,7 @@ export class ShapeRenderer implements Disposable {
}
}
dispose() {
dispose () {
this.mesh.dispose();
}
}

6
spine-ts/spine-webgl/src/SkeletonDebugRenderer.ts
View File

@ -58,11 +58,11 @@ export class SkeletonDebugRenderer implements Disposable {
private static LIGHT_GRAY = new Color(192 / 255, 192 / 255, 192 / 255, 1);
private static GREEN = new Color(0, 1, 0, 1);
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext) {
constructor (context: ManagedWebGLRenderingContext | WebGLRenderingContext) {
this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
}
draw(shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones: Array<string> = null) {
draw (shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones: Array<string> = null) {
let skeletonX = skeleton.x;
let skeletonY = skeleton.y;
let gl = this.context.gl;
@ -222,6 +222,6 @@ export class SkeletonDebugRenderer implements Disposable {
}
}
dispose() {
dispose () {
}
}

6
spine-ts/spine-webgl/src/SkeletonRenderer.ts
View File

@ -34,7 +34,7 @@ import { ManagedWebGLRenderingContext, WebGLBlendModeConverter } from "./WebGL";
class Renderable {
constructor(public vertices: NumberArrayLike, public numVertices: number, public numFloats: number) { }
constructor (public vertices: NumberArrayLike, public numVertices: number, public numFloats: number) { }
};
export class SkeletonRenderer {
@ -54,14 +54,14 @@ export class SkeletonRenderer {
private temp3 = new Color();
private temp4 = new Color();
constructor(context: ManagedWebGLRenderingContext, twoColorTint: boolean = true) {
constructor (context: ManagedWebGLRenderingContext, twoColorTint: boolean = true) {
this.twoColorTint = twoColorTint;
if (twoColorTint)
this.vertexSize += 4;
this.vertices = Utils.newFloatArray(this.vertexSize * 1024);
}
draw(batcher: PolygonBatcher, skeleton: Skeleton, slotRangeStart: number = -1, slotRangeEnd: number = -1) {
draw (batcher: PolygonBatcher, skeleton: Skeleton, slotRangeStart: number = -1, slotRangeEnd: number = -1) {
let clipper = this.clipper;
let premultipliedAlpha = this.premultipliedAlpha;
let twoColorTint = this.twoColorTint;

26
spine-ts/spine-webgl/src/Vector3.ts
View File

@ -34,48 +34,48 @@ export class Vector3 {
y = 0;
z = 0;
constructor(x: number = 0, y: number = 0, z: number = 0) {
constructor (x: number = 0, y: number = 0, z: number = 0) {
this.x = x;
this.y = y;
this.z = z;
}
setFrom(v: Vector3): Vector3 {
setFrom (v: Vector3): Vector3 {
this.x = v.x;
this.y = v.y;
this.z = v.z;
return this;
}
set(x: number, y: number, z: number): Vector3 {
set (x: number, y: number, z: number): Vector3 {
this.x = x;
this.y = y;
this.z = z;
return this;
}
add(v: Vector3): Vector3 {
add (v: Vector3): Vector3 {
this.x += v.x;
this.y += v.y;
this.z += v.z;
return this;
}
sub(v: Vector3): Vector3 {
sub (v: Vector3): Vector3 {
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
return this;
}
scale(s: number): Vector3 {
scale (s: number): Vector3 {
this.x *= s;
this.y *= s;
this.z *= s;
return this;
}
normalize(): Vector3 {
normalize (): Vector3 {
let len = this.length();
if (len == 0) return this;
len = 1 / len;
@ -85,18 +85,18 @@ export class Vector3 {
return this;
}
cross(v: Vector3): Vector3 {
cross (v: Vector3): Vector3 {
return this.set(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x)
}
multiply(matrix: Matrix4): Vector3 {
multiply (matrix: Matrix4): Vector3 {
let l_mat = matrix.values;
return this.set(this.x * l_mat[M00] + this.y * l_mat[M01] + this.z * l_mat[M02] + l_mat[M03],
this.x * l_mat[M10] + this.y * l_mat[M11] + this.z * l_mat[M12] + l_mat[M13],
this.x * l_mat[M20] + this.y * l_mat[M21] + this.z * l_mat[M22] + l_mat[M23]);
}
project(matrix: Matrix4): Vector3 {
project (matrix: Matrix4): Vector3 {
let l_mat = matrix.values;
let l_w = 1 / (this.x * l_mat[M30] + this.y * l_mat[M31] + this.z * l_mat[M32] + l_mat[M33]);
return this.set((this.x * l_mat[M00] + this.y * l_mat[M01] + this.z * l_mat[M02] + l_mat[M03]) * l_w,
@ -104,15 +104,15 @@ export class Vector3 {
(this.x * l_mat[M20] + this.y * l_mat[M21] + this.z * l_mat[M22] + l_mat[M23]) * l_w);
}
dot(v: Vector3): number {
dot (v: Vector3): number {
return this.x * v.x + this.y * v.y + this.z * v.z;
}
length(): number {
length (): number {
return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
}
distance(v: Vector3): number {
distance (v: Vector3): number {
let a = v.x - this.x;
let b = v.y - this.y;
let c = v.z - this.z;

14
spine-ts/spine-webgl/src/WebGL.ts
View File

@ -34,7 +34,7 @@ export class ManagedWebGLRenderingContext {
public gl: WebGLRenderingContext;
private restorables = new Array<Restorable>();
constructor(canvasOrContext: HTMLCanvasElement | WebGLRenderingContext | EventTarget, contextConfig: any = { alpha: "true" }) {
constructor (canvasOrContext: HTMLCanvasElement | WebGLRenderingContext | EventTarget, contextConfig: any = { alpha: "true" }) {
if (!((canvasOrContext instanceof WebGLRenderingContext) || (typeof WebGL2RenderingContext !== 'undefined' && canvasOrContext instanceof WebGL2RenderingContext)))
this.setupCanvas(canvasOrContext, contextConfig);
else {
@ -43,7 +43,7 @@ export class ManagedWebGLRenderingContext {
}
}
private setupCanvas(canvas: any, contextConfig: any) {
private setupCanvas (canvas: any, contextConfig: any) {
this.gl = <WebGLRenderingContext>(canvas.getContext("webgl2", contextConfig) || canvas.getContext("webgl", contextConfig));
this.canvas = canvas;
canvas.addEventListener("webglcontextlost", (e: any) => {
@ -57,11 +57,11 @@ export class ManagedWebGLRenderingContext {
});
}
addRestorable(restorable: Restorable) {
addRestorable (restorable: Restorable) {
this.restorables.push(restorable);
}
removeRestorable(restorable: Restorable) {
removeRestorable (restorable: Restorable) {
let index = this.restorables.indexOf(restorable);
if (index > -1) this.restorables.splice(index, 1);
}
@ -75,7 +75,7 @@ const ONE_MINUS_DST_ALPHA = 0x0305;
const DST_COLOR = 0x0306;
export class WebGLBlendModeConverter {
static getDestGLBlendMode(blendMode: BlendMode) {
static getDestGLBlendMode (blendMode: BlendMode) {
switch (blendMode) {
case BlendMode.Normal: return ONE_MINUS_SRC_ALPHA;
case BlendMode.Additive: return ONE;
@ -85,7 +85,7 @@ export class WebGLBlendModeConverter {
}
}
static getSourceColorGLBlendMode(blendMode: BlendMode, premultipliedAlpha: boolean = false) {
static getSourceColorGLBlendMode (blendMode: BlendMode, premultipliedAlpha: boolean = false) {
switch (blendMode) {
case BlendMode.Normal: return premultipliedAlpha ? ONE : SRC_ALPHA;
case BlendMode.Additive: return premultipliedAlpha ? ONE : SRC_ALPHA;
@ -95,7 +95,7 @@ export class WebGLBlendModeConverter {
}
}
static getSourceAlphaGLBlendMode(blendMode: BlendMode) {
static getSourceAlphaGLBlendMode (blendMode: BlendMode) {
switch (blendMode) {
case BlendMode.Normal: return ONE;
case BlendMode.Additive: return ONE;