mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-02-06 23:34:53 +08:00
[ts] Use constant values instead of static fields.
Even this ugliness is less ugly than TypeScript static field access. Smaller too.
This commit is contained in:
Nathan Sweet
parent
afcd899bca
commit
3ecf7929bf
@ -191,33 +191,30 @@ module spine {
|
||||
slotIndex: number;
|
||||
}
|
||||
|
||||
const LINEAR = 0; const STEPPED = 1; const BEZIER = 2;
|
||||
const BEZIER_SIZE = 18;
|
||||
|
||||
/** The base class for timelines that use interpolation between key frame values. */
|
||||
export abstract class CurveTimeline extends Timeline {
|
||||
protected curves: ArrayLike<number>; // type, x, y, ...
|
||||
|
||||
constructor (frameCount: number, bezierCount: number, propertyIds: string[]) {
|
||||
super(frameCount, propertyIds);
|
||||
this.curves = Utils.newFloatArray(frameCount + bezierCount * BEZIER_SIZE);
|
||||
this.curves[frameCount - 1] = STEPPED;
|
||||
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) {
|
||||
this.curves[frame] = LINEAR;
|
||||
this.curves[frame] = 0/*LINEAR*/;
|
||||
}
|
||||
|
||||
/** Sets the specified key frame to stepped interpolation. */
|
||||
setStepped (frame: number) {
|
||||
this.curves[frame] = STEPPED;
|
||||
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) {
|
||||
let size = this.getFrameCount() + bezierCount * BEZIER_SIZE;
|
||||
let size = this.getFrameCount() + bezierCount * 18/*BEZIER_SIZE*/;
|
||||
if (this.curves.length > size) {
|
||||
let newCurves = Utils.newFloatArray(size);
|
||||
Utils.arrayCopy(this.curves, 0, newCurves, 0, size);
|
||||
@ -242,14 +239,14 @@ module spine {
|
||||
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 * BEZIER_SIZE;
|
||||
if (value == 0) curves[frame] = BEZIER + i;
|
||||
let i = this.getFrameCount() + bezier * 18/*BEZIER_SIZE*/;
|
||||
if (value == 0) curves[frame] = 2/*BEZIER*/ + i;
|
||||
let tmpx = (time1 - cx1 * 2 + cx2) * 0.03, tmpy = (value1 - cy1 * 2 + cy2) * 0.03;
|
||||
let dddx = ((cx1 - cx2) * 3 - time1 + time2) * 0.006, dddy = ((cy1 - cy2) * 3 - value1 + value2) * 0.006;
|
||||
let ddx = tmpx * 2 + dddx, ddy = tmpy * 2 + dddy;
|
||||
let dx = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy = (cy1 - value1) * 0.3 + tmpy + dddy * 0.16666667;
|
||||
let x = time1 + dx, y = value1 + dy;
|
||||
for (let n = i + BEZIER_SIZE; i < n; i += 2) {
|
||||
for (let n = i + 18/*BEZIER_SIZE*/; i < n; i += 2) {
|
||||
curves[i] = x;
|
||||
curves[i + 1] = y;
|
||||
dx += ddx;
|
||||
@ -271,7 +268,7 @@ module spine {
|
||||
let x = this.frames[frameIndex], y = this.frames[frameIndex + valueOffset];
|
||||
return y + (time - x) / (curves[i] - x) * (curves[i + 1] - y);
|
||||
}
|
||||
let n = i + BEZIER_SIZE;
|
||||
let n = i + 18/*BEZIER_SIZE*/;
|
||||
for (i += 2; i < n; i += 2) {
|
||||
if (curves[i] >= time) {
|
||||
let x = curves[i - 2], y = curves[i - 1];
|
||||
@ -285,15 +282,12 @@ module spine {
|
||||
}
|
||||
|
||||
export abstract class CurveTimeline1 extends CurveTimeline {
|
||||
static ENTRIES = 2;
|
||||
static VALUE = 1;
|
||||
|
||||
constructor(frameCount: number, bezierCount: number, propertyIds: string[]) {
|
||||
super(frameCount, bezierCount, propertyIds);
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return CurveTimeline1.ENTRIES;
|
||||
return 2/*ENTRIES*/;
|
||||
}
|
||||
|
||||
/** Sets the time and value for the specified frame.
|
||||
@ -302,7 +296,7 @@ module spine {
|
||||
setFrame (frame: number, time: number, value: number) {
|
||||
frame <<= 1;
|
||||
this.frames[frame] = time;
|
||||
this.frames[frame + CurveTimeline1.VALUE] = value;
|
||||
this.frames[frame + 1/*VALUE*/] = value;
|
||||
}
|
||||
|
||||
/** Returns the interpolated value for the specified time. */
|
||||
@ -318,21 +312,18 @@ module spine {
|
||||
|
||||
let curveType = this.curves[i >> 1];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
let before = frames[i], value = frames[i + CurveTimeline1.VALUE];
|
||||
return value + (time - before) / (frames[i + CurveTimeline1.ENTRIES] - before) * (frames[i + CurveTimeline1.ENTRIES + CurveTimeline1.VALUE] - value);
|
||||
case STEPPED:
|
||||
return frames[i + CurveTimeline1.VALUE];
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i], value = frames[i + 1/*VALUE*/];
|
||||
return value + (time - before) / (frames[i + 2/*ENTRIES*/] - before) * (frames[i + 2/*ENTRIES*/ + 1/*VALUE*/] - value);
|
||||
case 1/*STEPPED*/:
|
||||
return frames[i + 1/*VALUE*/];
|
||||
}
|
||||
return this.getBezierValue(time, i, CurveTimeline1.VALUE, curveType - BEZIER);
|
||||
return this.getBezierValue(time, i, 1/*VALUE*/, curveType - 2/*BEZIER*/);
|
||||
}
|
||||
}
|
||||
|
||||
/** The base class for a {@link CurveTimeline} which sets two properties. */
|
||||
export abstract class CurveTimeline2 extends CurveTimeline {
|
||||
static ENTRIES = 3;
|
||||
static VALUE1 = 1; static VALUE2 = 2;
|
||||
|
||||
/** @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, propertyIds: string[]) {
|
||||
@ -340,17 +331,17 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return CurveTimeline2.ENTRIES;
|
||||
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) {
|
||||
frame *= CurveTimeline2.ENTRIES;
|
||||
frame *= 3/*ENTRIES*/;
|
||||
this.frames[frame] = time;
|
||||
this.frames[frame + CurveTimeline2.VALUE1] = value1;
|
||||
this.frames[frame + CurveTimeline2.VALUE2] = value2;
|
||||
this.frames[frame + 1/*VALUE1*/] = value1;
|
||||
this.frames[frame + 2/*VALUE2*/] = value2;
|
||||
}
|
||||
}
|
||||
|
||||
@ -426,24 +417,24 @@ module spine {
|
||||
}
|
||||
|
||||
let x = 0, y = 0;
|
||||
let i = Timeline.search2(frames, time, CurveTimeline2.ENTRIES);
|
||||
let curveType = this.curves[i / CurveTimeline2.ENTRIES];
|
||||
let i = Timeline.search2(frames, time, 3/*ENTRIES*/);
|
||||
let curveType = this.curves[i / 3/*ENTRIES*/];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
x = frames[i + CurveTimeline2.VALUE1];
|
||||
y = frames[i + CurveTimeline2.VALUE2];
|
||||
let t = (time - before) / (frames[i + CurveTimeline2.ENTRIES] - before);
|
||||
x += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE1] - x) * t;
|
||||
y += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE2] - y) * t;
|
||||
x = frames[i + 1/*VALUE1*/];
|
||||
y = frames[i + 2/*VALUE2*/];
|
||||
let t = (time - before) / (frames[i + 3/*ENTRIES*/] - before);
|
||||
x += (frames[i + 3/*ENTRIES*/ + 1/*VALUE1*/] - x) * t;
|
||||
y += (frames[i + 3/*ENTRIES*/ + 2/*VALUE2*/] - y) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
x = frames[i + CurveTimeline2.VALUE1];
|
||||
y = frames[i + CurveTimeline2.VALUE2];
|
||||
case 1/*STEPPED*/:
|
||||
x = frames[i + 1/*VALUE1*/];
|
||||
y = frames[i + 2/*VALUE2*/];
|
||||
break;
|
||||
default:
|
||||
x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - BEZIER);
|
||||
y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + BEZIER_SIZE - BEZIER);
|
||||
x = this.getBezierValue(time, i, 1/*VALUE1*/, curveType - 2/*BEZIER*/);
|
||||
y = this.getBezierValue(time, i, 2/*VALUE2*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
}
|
||||
|
||||
switch (blend) {
|
||||
@ -578,24 +569,24 @@ module spine {
|
||||
}
|
||||
|
||||
let x = 0, y = 0;
|
||||
let i = Timeline.search2(frames, time, CurveTimeline2.ENTRIES);
|
||||
let curveType = this.curves[i / CurveTimeline2.ENTRIES];
|
||||
let i = Timeline.search2(frames, time, 3/*ENTRIES*/);
|
||||
let curveType = this.curves[i / 3/*ENTRIES*/];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
x = frames[i + CurveTimeline2.VALUE1];
|
||||
y = frames[i + CurveTimeline2.VALUE2];
|
||||
let t = (time - before) / (frames[i + CurveTimeline2.ENTRIES] - before);
|
||||
x += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE1] - x) * t;
|
||||
y += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE2] - y) * t;
|
||||
x = frames[i + 1/*VALUE1*/];
|
||||
y = frames[i + 2/*VALUE2*/];
|
||||
let t = (time - before) / (frames[i + 3/*ENTRIES*/] - before);
|
||||
x += (frames[i + 3/*ENTRIES*/ + 1/*VALUE1*/] - x) * t;
|
||||
y += (frames[i + 3/*ENTRIES*/ + 2/*VALUE2*/] - y) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
x = frames[i + CurveTimeline2.VALUE1];
|
||||
y = frames[i + CurveTimeline2.VALUE2];
|
||||
case 1/*STEPPED*/:
|
||||
x = frames[i + 1/*VALUE1*/];
|
||||
y = frames[i + 2/*VALUE2*/];
|
||||
break;
|
||||
default:
|
||||
x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - BEZIER);
|
||||
y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + BEZIER_SIZE - BEZIER);
|
||||
x = this.getBezierValue(time, i, 1/*VALUE1*/, curveType - 2/*BEZIER*/);
|
||||
y = this.getBezierValue(time, i, 2/*VALUE2*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
}
|
||||
x *= bone.data.scaleX;
|
||||
y *= bone.data.scaleY;
|
||||
@ -830,24 +821,24 @@ module spine {
|
||||
}
|
||||
|
||||
let x = 0, y = 0;
|
||||
let i = Timeline.search2(frames, time, CurveTimeline2.ENTRIES);
|
||||
let curveType = this.curves[i / CurveTimeline2.ENTRIES];
|
||||
let i = Timeline.search2(frames, time, 3/*ENTRIES*/);
|
||||
let curveType = this.curves[i / 3/*ENTRIES*/];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
x = frames[i + CurveTimeline2.VALUE1];
|
||||
y = frames[i + CurveTimeline2.VALUE2];
|
||||
let t = (time - before) / (frames[i + CurveTimeline2.ENTRIES] - before);
|
||||
x += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE1] - x) * t;
|
||||
y += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE2] - y) * t;
|
||||
x = frames[i + 1/*VALUE1*/];
|
||||
y = frames[i + 2/*VALUE2*/];
|
||||
let t = (time - before) / (frames[i + 3/*ENTRIES*/] - before);
|
||||
x += (frames[i + 3/*ENTRIES*/ + 1/*VALUE1*/] - x) * t;
|
||||
y += (frames[i + 3/*ENTRIES*/ + 2/*VALUE2*/] - y) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
x = frames[i + CurveTimeline2.VALUE1];
|
||||
y = frames[i + CurveTimeline2.VALUE2];
|
||||
case 1/*STEPPED*/:
|
||||
x = frames[i + 1/*VALUE1*/];
|
||||
y = frames[i + 2/*VALUE2*/];
|
||||
break;
|
||||
default:
|
||||
x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - BEZIER);
|
||||
y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + BEZIER_SIZE - BEZIER);
|
||||
x = this.getBezierValue(time, i, 1/*VALUE1*/, curveType - 2/*BEZIER*/);
|
||||
y = this.getBezierValue(time, i, 2/*VALUE2*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
}
|
||||
|
||||
switch (blend) {
|
||||
@ -953,9 +944,6 @@ module spine {
|
||||
|
||||
/** Changes a slot's {@link Slot#color}. */
|
||||
export class RGBATimeline extends CurveTimeline implements SlotTimeline {
|
||||
static ENTRIES = 5;
|
||||
static R = 1; static G = 2; static B = 3; static A = 4;
|
||||
|
||||
slotIndex = 0;
|
||||
|
||||
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
|
||||
@ -967,17 +955,17 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return RGBATimeline.ENTRIES;
|
||||
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) {
|
||||
frame *= RGBATimeline.ENTRIES;
|
||||
frame *= 5/*ENTRIES*/;
|
||||
this.frames[frame] = time;
|
||||
this.frames[frame + RGBATimeline.R] = r;
|
||||
this.frames[frame + RGBATimeline.G] = g;
|
||||
this.frames[frame + RGBATimeline.B] = b;
|
||||
this.frames[frame + RGBATimeline.A] = a;
|
||||
this.frames[frame + 1/*R*/] = r;
|
||||
this.frames[frame + 2/*G*/] = g;
|
||||
this.frames[frame + 3/*B*/] = b;
|
||||
this.frames[frame + 4/*A*/] = a;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
|
||||
@ -1000,32 +988,32 @@ module spine {
|
||||
}
|
||||
|
||||
let r = 0, g = 0, b = 0, a = 0;
|
||||
let i = Timeline.search2(frames, time, RGBATimeline.ENTRIES);
|
||||
let curveType = this.curves[i / RGBATimeline.ENTRIES];
|
||||
let i = Timeline.search2(frames, time, 5/*ENTRIES*/);
|
||||
let curveType = this.curves[i / 5/*ENTRIES*/];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
r = frames[i + RGBATimeline.R];
|
||||
g = frames[i + RGBATimeline.G];
|
||||
b = frames[i + RGBATimeline.B];
|
||||
a = frames[i + RGBATimeline.A];
|
||||
let t = (time - before) / (frames[i + RGBATimeline.ENTRIES] - before);
|
||||
r += (frames[i + RGBATimeline.ENTRIES + RGBATimeline.R] - r) * t;
|
||||
g += (frames[i + RGBATimeline.ENTRIES + RGBATimeline.G] - g) * t;
|
||||
b += (frames[i + RGBATimeline.ENTRIES + RGBATimeline.B] - b) * t;
|
||||
a += (frames[i + RGBATimeline.ENTRIES + RGBATimeline.A] - a) * t;
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
a = frames[i + 4/*A*/];
|
||||
let t = (time - before) / (frames[i + 5/*ENTRIES*/] - before);
|
||||
r += (frames[i + 5/*ENTRIES*/ + 1/*R*/] - r) * t;
|
||||
g += (frames[i + 5/*ENTRIES*/ + 2/*G*/] - g) * t;
|
||||
b += (frames[i + 5/*ENTRIES*/ + 3/*B*/] - b) * t;
|
||||
a += (frames[i + 5/*ENTRIES*/ + 4/*A*/] - a) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
r = frames[i + RGBATimeline.R];
|
||||
g = frames[i + RGBATimeline.G];
|
||||
b = frames[i + RGBATimeline.B];
|
||||
a = frames[i + RGBATimeline.A];
|
||||
case 1/*STEPPED*/:
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
a = frames[i + 4/*A*/];
|
||||
break;
|
||||
default:
|
||||
r = this.getBezierValue(time, i, RGBATimeline.R, curveType - BEZIER);
|
||||
g = this.getBezierValue(time, i, RGBATimeline.G, curveType + BEZIER_SIZE - BEZIER);
|
||||
b = this.getBezierValue(time, i, RGBATimeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
|
||||
a = this.getBezierValue(time, i, RGBATimeline.A, curveType + BEZIER_SIZE * 3 - BEZIER);
|
||||
r = this.getBezierValue(time, i, 1/*R*/, curveType - 2/*BEZIER*/);
|
||||
g = this.getBezierValue(time, i, 2/*G*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
b = this.getBezierValue(time, i, 3/*B*/, curveType + 18/*BEZIER_SIZE*/ * 2 - 2/*BEZIER*/);
|
||||
a = this.getBezierValue(time, i, 4/*A*/, curveType + 18/*BEZIER_SIZE*/ * 3 - 2/*BEZIER*/);
|
||||
}
|
||||
if (alpha == 1)
|
||||
color.set(r, g, b, a);
|
||||
@ -1038,9 +1026,6 @@ module spine {
|
||||
|
||||
/** Changes a slot's {@link Slot#color}. */
|
||||
export class RGBTimeline extends CurveTimeline implements SlotTimeline {
|
||||
static ENTRIES = 4;
|
||||
static R = 1; static G = 2; static B = 3;
|
||||
|
||||
slotIndex = 0;
|
||||
|
||||
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
|
||||
@ -1051,16 +1036,16 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return RGBTimeline.ENTRIES;
|
||||
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) {
|
||||
frame <<= 2;
|
||||
this.frames[frame] = time;
|
||||
this.frames[frame + RGBTimeline.R] = r;
|
||||
this.frames[frame + RGBTimeline.G] = g;
|
||||
this.frames[frame + RGBTimeline.B] = b;
|
||||
this.frames[frame + 1/*R*/] = r;
|
||||
this.frames[frame + 2/*G*/] = g;
|
||||
this.frames[frame + 3/*B*/] = b;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
|
||||
@ -1086,28 +1071,28 @@ module spine {
|
||||
}
|
||||
|
||||
let r = 0, g = 0, b = 0;
|
||||
let i = Timeline.search2(frames, time, RGBTimeline.ENTRIES);
|
||||
let i = Timeline.search2(frames, time, 4/*ENTRIES*/);
|
||||
let curveType = this.curves[i >> 2];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
r = frames[i + RGBTimeline.R];
|
||||
g = frames[i + RGBTimeline.G];
|
||||
b = frames[i + RGBTimeline.B];
|
||||
let t = (time - before) / (frames[i + RGBTimeline.ENTRIES] - before);
|
||||
r += (frames[i + RGBTimeline.ENTRIES + RGBTimeline.R] - r) * t;
|
||||
g += (frames[i + RGBTimeline.ENTRIES + RGBTimeline.G] - g) * t;
|
||||
b += (frames[i + RGBTimeline.ENTRIES + RGBTimeline.B] - b) * t;
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
let t = (time - before) / (frames[i + 4/*ENTRIES*/] - before);
|
||||
r += (frames[i + 4/*ENTRIES*/ + 1/*R*/] - r) * t;
|
||||
g += (frames[i + 4/*ENTRIES*/ + 2/*G*/] - g) * t;
|
||||
b += (frames[i + 4/*ENTRIES*/ + 3/*B*/] - b) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
r = frames[i + RGBTimeline.R];
|
||||
g = frames[i + RGBTimeline.G];
|
||||
b = frames[i + RGBTimeline.B];
|
||||
case 1/*STEPPED*/:
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
break;
|
||||
default:
|
||||
r = this.getBezierValue(time, i, RGBTimeline.R, curveType - BEZIER);
|
||||
g = this.getBezierValue(time, i, RGBTimeline.G, curveType + BEZIER_SIZE - BEZIER);
|
||||
b = this.getBezierValue(time, i, RGBTimeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
|
||||
r = this.getBezierValue(time, i, 1/*R*/, curveType - 2/*BEZIER*/);
|
||||
g = this.getBezierValue(time, i, 2/*G*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
b = this.getBezierValue(time, i, 3/*B*/, curveType + 18/*BEZIER_SIZE*/ * 2 - 2/*BEZIER*/);
|
||||
}
|
||||
if (alpha == 1) {
|
||||
color.r = r;
|
||||
@ -1167,9 +1152,6 @@ module spine {
|
||||
|
||||
/** Changes a slot's {@link Slot#color} and {@link Slot#darkColor} for two color tinting. */
|
||||
export class RGBA2Timeline extends CurveTimeline implements SlotTimeline{
|
||||
static ENTRIES = 8;
|
||||
static R = 1; static G = 2; static B = 3; static A = 4; static R2 = 5; static G2 = 6; static B2 = 7;
|
||||
|
||||
slotIndex = 0;
|
||||
|
||||
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
|
||||
@ -1182,20 +1164,20 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return RGBA2Timeline.ENTRIES;
|
||||
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) {
|
||||
frame <<= 3;
|
||||
this.frames[frame] = time;
|
||||
this.frames[frame + RGBA2Timeline.R] = r;
|
||||
this.frames[frame + RGBA2Timeline.G] = g;
|
||||
this.frames[frame + RGBA2Timeline.B] = b;
|
||||
this.frames[frame + RGBA2Timeline.A] = a;
|
||||
this.frames[frame + RGBA2Timeline.R2] = r2;
|
||||
this.frames[frame + RGBA2Timeline.G2] = g2;
|
||||
this.frames[frame + RGBA2Timeline.B2] = b2;
|
||||
this.frames[frame + 1/*R*/] = r;
|
||||
this.frames[frame + 2/*G*/] = g;
|
||||
this.frames[frame + 3/*B*/] = b;
|
||||
this.frames[frame + 4/*A*/] = a;
|
||||
this.frames[frame + 5/*R2*/] = r2;
|
||||
this.frames[frame + 6/*G2*/] = g2;
|
||||
this.frames[frame + 7/*B2*/] = b2;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
|
||||
@ -1224,44 +1206,44 @@ module spine {
|
||||
}
|
||||
|
||||
let r = 0, g = 0, b = 0, a = 0, r2 = 0, g2 = 0, b2 = 0;
|
||||
let i = Timeline.search2(frames, time, RGBA2Timeline.ENTRIES);
|
||||
let i = Timeline.search2(frames, time, 8/*ENTRIES*/);
|
||||
let curveType = this.curves[i >> 3];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
r = frames[i + RGBA2Timeline.R];
|
||||
g = frames[i + RGBA2Timeline.G];
|
||||
b = frames[i + RGBA2Timeline.B];
|
||||
a = frames[i + RGBA2Timeline.A];
|
||||
r2 = frames[i + RGBA2Timeline.R2];
|
||||
g2 = frames[i + RGBA2Timeline.G2];
|
||||
b2 = frames[i + RGBA2Timeline.B2];
|
||||
let t = (time - before) / (frames[i + RGBA2Timeline.ENTRIES] - before);
|
||||
r += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.R] - r) * t;
|
||||
g += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.G] - g) * t;
|
||||
b += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.B] - b) * t;
|
||||
a += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.A] - a) * t;
|
||||
r2 += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.R2] - r2) * t;
|
||||
g2 += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.G2] - g2) * t;
|
||||
b2 += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.B2] - b2) * t;
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
a = frames[i + 4/*A*/];
|
||||
r2 = frames[i + 5/*R2*/];
|
||||
g2 = frames[i + 6/*G2*/];
|
||||
b2 = frames[i + 7/*B2*/];
|
||||
let t = (time - before) / (frames[i + 8/*ENTRIES*/] - before);
|
||||
r += (frames[i + 8/*ENTRIES*/ + 1/*R*/] - r) * t;
|
||||
g += (frames[i + 8/*ENTRIES*/ + 2/*G*/] - g) * t;
|
||||
b += (frames[i + 8/*ENTRIES*/ + 3/*B*/] - b) * t;
|
||||
a += (frames[i + 8/*ENTRIES*/ + 4/*A*/] - a) * t;
|
||||
r2 += (frames[i + 8/*ENTRIES*/ + 5/*R2*/] - r2) * t;
|
||||
g2 += (frames[i + 8/*ENTRIES*/ + 6/*G2*/] - g2) * t;
|
||||
b2 += (frames[i + 8/*ENTRIES*/ + 7/*B2*/] - b2) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
r = frames[i + RGBA2Timeline.R];
|
||||
g = frames[i + RGBA2Timeline.G];
|
||||
b = frames[i + RGBA2Timeline.B];
|
||||
a = frames[i + RGBA2Timeline.A];
|
||||
r2 = frames[i + RGBA2Timeline.R2];
|
||||
g2 = frames[i + RGBA2Timeline.G2];
|
||||
b2 = frames[i + RGBA2Timeline.B2];
|
||||
case 1/*STEPPED*/:
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
a = frames[i + 4/*A*/];
|
||||
r2 = frames[i + 5/*R2*/];
|
||||
g2 = frames[i + 6/*G2*/];
|
||||
b2 = frames[i + 7/*B2*/];
|
||||
break;
|
||||
default:
|
||||
r = this.getBezierValue(time, i, RGBA2Timeline.R, curveType - BEZIER);
|
||||
g = this.getBezierValue(time, i, RGBA2Timeline.G, curveType + BEZIER_SIZE - BEZIER);
|
||||
b = this.getBezierValue(time, i, RGBA2Timeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
|
||||
a = this.getBezierValue(time, i, RGBA2Timeline.A, curveType + BEZIER_SIZE * 3 - BEZIER);
|
||||
r2 = this.getBezierValue(time, i, RGBA2Timeline.R2, curveType + BEZIER_SIZE * 4 - BEZIER);
|
||||
g2 = this.getBezierValue(time, i, RGBA2Timeline.G2, curveType + BEZIER_SIZE * 5 - BEZIER);
|
||||
b2 = this.getBezierValue(time, i, RGBA2Timeline.B2, curveType + BEZIER_SIZE * 6 - BEZIER);
|
||||
r = this.getBezierValue(time, i, 1/*R*/, curveType - 2/*BEZIER*/);
|
||||
g = this.getBezierValue(time, i, 2/*G*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
b = this.getBezierValue(time, i, 3/*B*/, curveType + 18/*BEZIER_SIZE*/ * 2 - 2/*BEZIER*/);
|
||||
a = this.getBezierValue(time, i, 4/*A*/, curveType + 18/*BEZIER_SIZE*/ * 3 - 2/*BEZIER*/);
|
||||
r2 = this.getBezierValue(time, i, 5/*R2*/, curveType + 18/*BEZIER_SIZE*/ * 4 - 2/*BEZIER*/);
|
||||
g2 = this.getBezierValue(time, i, 6/*G2*/, curveType + 18/*BEZIER_SIZE*/ * 5 - 2/*BEZIER*/);
|
||||
b2 = this.getBezierValue(time, i, 7/*B2*/, curveType + 18/*BEZIER_SIZE*/ * 6 - 2/*BEZIER*/);
|
||||
}
|
||||
|
||||
if (alpha == 1) {
|
||||
@ -1284,9 +1266,6 @@ module spine {
|
||||
|
||||
/** Changes a slot's {@link Slot#color} and {@link Slot#darkColor} for two color tinting. */
|
||||
export class RGB2Timeline extends CurveTimeline implements SlotTimeline{
|
||||
static ENTRIES = 7;
|
||||
static R = 1; static G = 2; static B = 3; static R2 = 4; static G2 = 5; static B2 = 6;
|
||||
|
||||
slotIndex = 0;
|
||||
|
||||
constructor (frameCount: number, bezierCount: number, slotIndex: number) {
|
||||
@ -1298,19 +1277,19 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return RGB2Timeline.ENTRIES;
|
||||
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) {
|
||||
frame *= RGB2Timeline.ENTRIES;
|
||||
frame *= 7/*ENTRIES*/;
|
||||
this.frames[frame] = time;
|
||||
this.frames[frame + RGB2Timeline.R] = r;
|
||||
this.frames[frame + RGB2Timeline.G] = g;
|
||||
this.frames[frame + RGB2Timeline.B] = b;
|
||||
this.frames[frame + RGB2Timeline.R2] = r2;
|
||||
this.frames[frame + RGB2Timeline.G2] = g2;
|
||||
this.frames[frame + RGB2Timeline.B2] = b2;
|
||||
this.frames[frame + 1/*R*/] = r;
|
||||
this.frames[frame + 2/*G*/] = g;
|
||||
this.frames[frame + 3/*B*/] = b;
|
||||
this.frames[frame + 4/*R2*/] = r2;
|
||||
this.frames[frame + 5/*G2*/] = g2;
|
||||
this.frames[frame + 6/*B2*/] = b2;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
|
||||
@ -1342,40 +1321,40 @@ module spine {
|
||||
}
|
||||
|
||||
let r = 0, g = 0, b = 0, a = 0, r2 = 0, g2 = 0, b2 = 0;
|
||||
let i = Timeline.search2(frames, time, RGB2Timeline.ENTRIES);
|
||||
let curveType = this.curves[i / RGB2Timeline.ENTRIES];
|
||||
let i = Timeline.search2(frames, time, 7/*ENTRIES*/);
|
||||
let curveType = this.curves[i / 7/*ENTRIES*/];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
r = frames[i + RGB2Timeline.R];
|
||||
g = frames[i + RGB2Timeline.G];
|
||||
b = frames[i + RGB2Timeline.B];
|
||||
r2 = frames[i + RGB2Timeline.R2];
|
||||
g2 = frames[i + RGB2Timeline.G2];
|
||||
b2 = frames[i + RGB2Timeline.B2];
|
||||
let t = (time - before) / (frames[i + RGB2Timeline.ENTRIES] - before);
|
||||
r += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.R] - r) * t;
|
||||
g += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.G] - g) * t;
|
||||
b += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.B] - b) * t;
|
||||
r2 += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.R2] - r2) * t;
|
||||
g2 += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.G2] - g2) * t;
|
||||
b2 += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.B2] - b2) * t;
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
r2 = frames[i + 4/*R2*/];
|
||||
g2 = frames[i + 5/*G2*/];
|
||||
b2 = frames[i + 6/*B2*/];
|
||||
let t = (time - before) / (frames[i + 7/*ENTRIES*/] - before);
|
||||
r += (frames[i + 7/*ENTRIES*/ + 1/*R*/] - r) * t;
|
||||
g += (frames[i + 7/*ENTRIES*/ + 2/*G*/] - g) * t;
|
||||
b += (frames[i + 7/*ENTRIES*/ + 3/*B*/] - b) * t;
|
||||
r2 += (frames[i + 7/*ENTRIES*/ + 4/*R2*/] - r2) * t;
|
||||
g2 += (frames[i + 7/*ENTRIES*/ + 5/*G2*/] - g2) * t;
|
||||
b2 += (frames[i + 7/*ENTRIES*/ + 6/*B2*/] - b2) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
r = frames[i + RGB2Timeline.R];
|
||||
g = frames[i + RGB2Timeline.G];
|
||||
b = frames[i + RGB2Timeline.B];
|
||||
r2 = frames[i + RGB2Timeline.R2];
|
||||
g2 = frames[i + RGB2Timeline.G2];
|
||||
b2 = frames[i + RGB2Timeline.B2];
|
||||
case 1/*STEPPED*/:
|
||||
r = frames[i + 1/*R*/];
|
||||
g = frames[i + 2/*G*/];
|
||||
b = frames[i + 3/*B*/];
|
||||
r2 = frames[i + 4/*R2*/];
|
||||
g2 = frames[i + 5/*G2*/];
|
||||
b2 = frames[i + 6/*B2*/];
|
||||
break;
|
||||
default:
|
||||
r = this.getBezierValue(time, i, RGB2Timeline.R, curveType - BEZIER);
|
||||
g = this.getBezierValue(time, i, RGB2Timeline.G, curveType + BEZIER_SIZE - BEZIER);
|
||||
b = this.getBezierValue(time, i, RGB2Timeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
|
||||
r2 = this.getBezierValue(time, i, RGB2Timeline.R2, curveType + BEZIER_SIZE * 3 - BEZIER);
|
||||
g2 = this.getBezierValue(time, i, RGB2Timeline.G2, curveType + BEZIER_SIZE * 4 - BEZIER);
|
||||
b2 = this.getBezierValue(time, i, RGB2Timeline.B2, curveType + BEZIER_SIZE * 5 - BEZIER);
|
||||
r = this.getBezierValue(time, i, 1/*R*/, curveType - 2/*BEZIER*/);
|
||||
g = this.getBezierValue(time, i, 2/*G*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
b = this.getBezierValue(time, i, 3/*B*/, curveType + 18/*BEZIER_SIZE*/ * 2 - 2/*BEZIER*/);
|
||||
r2 = this.getBezierValue(time, i, 4/*R2*/, curveType + 18/*BEZIER_SIZE*/ * 3 - 2/*BEZIER*/);
|
||||
g2 = this.getBezierValue(time, i, 5/*G2*/, curveType + 18/*BEZIER_SIZE*/ * 4 - 2/*BEZIER*/);
|
||||
b2 = this.getBezierValue(time, i, 6/*B2*/, curveType + 18/*BEZIER_SIZE*/ * 5 - 2/*BEZIER*/);
|
||||
}
|
||||
|
||||
if (alpha == 1) {
|
||||
@ -1487,14 +1466,14 @@ module spine {
|
||||
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 * BEZIER_SIZE;
|
||||
if (value == 0) curves[frame] = BEZIER + i;
|
||||
let i = this.getFrameCount() + bezier * 18/*BEZIER_SIZE*/;
|
||||
if (value == 0) curves[frame] = 2/*BEZIER*/ + i;
|
||||
let tmpx = (time1 - cx1 * 2 + cx2) * 0.03, tmpy = cy2 * 0.03 - cy1 * 0.06;
|
||||
let dddx = ((cx1 - cx2) * 3 - time1 + time2) * 0.006, dddy = (cy1 - cy2 + 0.33333333) * 0.018;
|
||||
let ddx = tmpx * 2 + dddx, ddy = tmpy * 2 + dddy;
|
||||
let dx = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy = cy1 * 0.3 + tmpy + dddy * 0.16666667;
|
||||
let x = time1 + dx, y = dy;
|
||||
for (let n = i + BEZIER_SIZE; i < n; i += 2) {
|
||||
for (let n = i + 18/*BEZIER_SIZE*/; i < n; i += 2) {
|
||||
curves[i] = x;
|
||||
curves[i + 1] = y;
|
||||
dx += ddx;
|
||||
@ -1510,18 +1489,18 @@ module spine {
|
||||
let curves = this.curves;
|
||||
let i = curves[frame];
|
||||
switch (i) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let x = this.frames[frame];
|
||||
return (time - x) / (this.frames[frame + this.getFrameEntries()] - x);
|
||||
case STEPPED:
|
||||
case 1/*STEPPED*/:
|
||||
return 0;
|
||||
}
|
||||
i -= BEZIER;
|
||||
i -= 2/*BEZIER*/;
|
||||
if (curves[i] > time) {
|
||||
let x = this.frames[frame];
|
||||
return curves[i + 1] * (time - x) / (curves[i] - x);
|
||||
}
|
||||
let n = i + BEZIER_SIZE;
|
||||
let n = i + 18/*BEZIER_SIZE*/;
|
||||
for (i += 2; i < n; i += 2) {
|
||||
if (curves[i] >= time) {
|
||||
let x = curves[i - 2], y = curves[i - 1];
|
||||
@ -1810,9 +1789,6 @@ module spine {
|
||||
/** Changes an IK constraint's {@link IkConstraint#mix}, {@link IkConstraint#softness},
|
||||
* {@link IkConstraint#bendDirection}, {@link IkConstraint#stretch}, and {@link IkConstraint#compress}. */
|
||||
export class IkConstraintTimeline extends CurveTimeline {
|
||||
static ENTRIES = 6;
|
||||
static MIX = 1; static SOFTNESS = 2; static BEND_DIRECTION = 3; static COMPRESS = 4; static STRETCH = 5;
|
||||
|
||||
/** The index of the IK constraint slot in {@link Skeleton#ikConstraints} that will be changed. */
|
||||
ikConstraintIndex: number;
|
||||
|
||||
@ -1824,18 +1800,18 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return IkConstraintTimeline.ENTRIES;
|
||||
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) {
|
||||
frame *= IkConstraintTimeline.ENTRIES;
|
||||
frame *= 6/*ENTRIES*/;
|
||||
this.frames[frame] = time;
|
||||
this.frames[frame + IkConstraintTimeline.MIX] = mix;
|
||||
this.frames[frame + IkConstraintTimeline.SOFTNESS] = softness;
|
||||
this.frames[frame + IkConstraintTimeline.BEND_DIRECTION] = bendDirection;
|
||||
this.frames[frame + IkConstraintTimeline.COMPRESS] = compress ? 1 : 0;
|
||||
this.frames[frame + IkConstraintTimeline.STRETCH] = stretch ? 1 : 0;
|
||||
this.frames[frame + 1/*MIX*/] = mix;
|
||||
this.frames[frame + 2/*SOFTNESS*/] = softness;
|
||||
this.frames[frame + 3/*BEND_DIRECTION*/] = bendDirection;
|
||||
this.frames[frame + 4/*COMPRESS*/] = compress ? 1 : 0;
|
||||
this.frames[frame + 5/*STRETCH*/] = stretch ? 1 : 0;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
|
||||
@ -1863,24 +1839,24 @@ module spine {
|
||||
}
|
||||
|
||||
let mix = 0, softness = 0;
|
||||
let i = Timeline.search2(frames, time, IkConstraintTimeline.ENTRIES)
|
||||
let curveType = this.curves[i / IkConstraintTimeline.ENTRIES];
|
||||
let i = Timeline.search2(frames, time, 6/*ENTRIES*/)
|
||||
let curveType = this.curves[i / 6/*ENTRIES*/];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
mix = frames[i + IkConstraintTimeline.MIX];
|
||||
softness = frames[i + IkConstraintTimeline.SOFTNESS];
|
||||
let t = (time - before) / (frames[i + IkConstraintTimeline.ENTRIES] - before);
|
||||
mix += (frames[i + IkConstraintTimeline.ENTRIES + IkConstraintTimeline.MIX] - mix) * t;
|
||||
softness += (frames[i + IkConstraintTimeline.ENTRIES + IkConstraintTimeline.SOFTNESS] - softness) * t;
|
||||
mix = frames[i + 1/*MIX*/];
|
||||
softness = frames[i + 2/*SOFTNESS*/];
|
||||
let t = (time - before) / (frames[i + 6/*ENTRIES*/] - before);
|
||||
mix += (frames[i + 6/*ENTRIES*/ + 1/*MIX*/] - mix) * t;
|
||||
softness += (frames[i + 6/*ENTRIES*/ + 2/*SOFTNESS*/] - softness) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
mix = frames[i + IkConstraintTimeline.MIX];
|
||||
softness = frames[i + IkConstraintTimeline.SOFTNESS];
|
||||
case 1/*STEPPED*/:
|
||||
mix = frames[i + 1/*MIX*/];
|
||||
softness = frames[i + 2/*SOFTNESS*/];
|
||||
break;
|
||||
default:
|
||||
mix = this.getBezierValue(time, i, IkConstraintTimeline.MIX, curveType - BEZIER);
|
||||
softness = this.getBezierValue(time, i, IkConstraintTimeline.SOFTNESS, curveType + BEZIER_SIZE - BEZIER);
|
||||
mix = this.getBezierValue(time, i, 1/*MIX*/, curveType - 2/*BEZIER*/);
|
||||
softness = this.getBezierValue(time, i, 2/*SOFTNESS*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
}
|
||||
|
||||
if (blend == MixBlend.setup) {
|
||||
@ -1892,17 +1868,17 @@ module spine {
|
||||
constraint.compress = constraint.data.compress;
|
||||
constraint.stretch = constraint.data.stretch;
|
||||
} else {
|
||||
constraint.bendDirection = frames[i + IkConstraintTimeline.BEND_DIRECTION];
|
||||
constraint.compress = frames[i + IkConstraintTimeline.COMPRESS] != 0;
|
||||
constraint.stretch = frames[i + IkConstraintTimeline.STRETCH] != 0;
|
||||
constraint.bendDirection = frames[i + 3/*BEND_DIRECTION*/];
|
||||
constraint.compress = frames[i + 4/*COMPRESS*/] != 0;
|
||||
constraint.stretch = frames[i + 5/*STRETCH*/] != 0;
|
||||
}
|
||||
} else {
|
||||
constraint.mix += (mix - constraint.mix) * alpha;
|
||||
constraint.softness += (softness - constraint.softness) * alpha;
|
||||
if (direction == MixDirection.mixIn) {
|
||||
constraint.bendDirection = frames[i + IkConstraintTimeline.BEND_DIRECTION];
|
||||
constraint.compress = frames[i + IkConstraintTimeline.COMPRESS] != 0;
|
||||
constraint.stretch = frames[i + IkConstraintTimeline.STRETCH] != 0;
|
||||
constraint.bendDirection = frames[i + 3/*BEND_DIRECTION*/];
|
||||
constraint.compress = frames[i + 4/*COMPRESS*/] != 0;
|
||||
constraint.stretch = frames[i + 5/*STRETCH*/] != 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1911,9 +1887,6 @@ module spine {
|
||||
/** Changes a transform constraint's {@link TransformConstraint#rotateMix}, {@link TransformConstraint#translateMix},
|
||||
* {@link TransformConstraint#scaleMix}, and {@link TransformConstraint#shearMix}. */
|
||||
export class TransformConstraintTimeline extends CurveTimeline {
|
||||
static ENTRIES = 7;
|
||||
static ROTATE = 1; static X = 2; static Y = 3; static SCALEX = 4; static SCALEY = 5; static SHEARY = 6;
|
||||
|
||||
/** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */
|
||||
transformConstraintIndex: number;
|
||||
|
||||
@ -1925,21 +1898,21 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return TransformConstraintTimeline.ENTRIES;
|
||||
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,
|
||||
mixShearY: number) {
|
||||
let frames = this.frames;
|
||||
frame *= TransformConstraintTimeline.ENTRIES;
|
||||
frame *= 7/*ENTRIES*/;
|
||||
frames[frame] = time;
|
||||
frames[frame + TransformConstraintTimeline.ROTATE] = mixRotate;
|
||||
frames[frame + TransformConstraintTimeline.X] = mixX;
|
||||
frames[frame + TransformConstraintTimeline.Y] = mixY;
|
||||
frames[frame + TransformConstraintTimeline.SCALEX] = mixScaleX;
|
||||
frames[frame + TransformConstraintTimeline.SCALEY] = mixScaleY;
|
||||
frames[frame + TransformConstraintTimeline.SHEARY] = mixShearY;
|
||||
frames[frame + 1/*ROTATE*/] = mixRotate;
|
||||
frames[frame + 2/*X*/] = mixX;
|
||||
frames[frame + 3/*Y*/] = mixY;
|
||||
frames[frame + 4/*SCALEX*/] = mixScaleX;
|
||||
frames[frame + 5/*SCALEY*/] = mixScaleY;
|
||||
frames[frame + 6/*SHEARY*/] = mixShearY;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
|
||||
@ -1969,47 +1942,41 @@ module spine {
|
||||
return;
|
||||
}
|
||||
|
||||
let X = TransformConstraintTimeline.X, Y = TransformConstraintTimeline.Y;
|
||||
let SCALEX = TransformConstraintTimeline.SCALEX, SCALEY = TransformConstraintTimeline.SCALEY;
|
||||
let SHEARY = TransformConstraintTimeline.SHEARY;
|
||||
let ENTRIES = TransformConstraintTimeline.ENTRIES;
|
||||
|
||||
let rotate, x, y, scaleX, scaleY, shearY;
|
||||
let i = Timeline.search2(frames, time, ENTRIES);
|
||||
let curveType = this.curves[i / ENTRIES];
|
||||
let ROTATE = TransformConstraintTimeline.ROTATE;
|
||||
let i = Timeline.search2(frames, time, 7/*ENTRIES*/);
|
||||
let curveType = this.curves[i / 7/*ENTRIES*/];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
rotate = frames[i + ROTATE];
|
||||
x = frames[i + X];
|
||||
y = frames[i + Y];
|
||||
scaleX = frames[i + SCALEX];
|
||||
scaleY = frames[i + SCALEY];
|
||||
shearY = frames[i + SHEARY];
|
||||
let t = (time - before) / (frames[i + ENTRIES] - before);
|
||||
rotate += (frames[i + ENTRIES + ROTATE] - rotate) * t;
|
||||
x += (frames[i + ENTRIES + X] - x) * t;
|
||||
y += (frames[i + ENTRIES + Y] - y) * t;
|
||||
scaleX += (frames[i + ENTRIES + SCALEX] - scaleX) * t;
|
||||
scaleY += (frames[i + ENTRIES + SCALEY] - scaleY) * t;
|
||||
shearY += (frames[i + ENTRIES + SHEARY] - shearY) * t;
|
||||
rotate = frames[i + 1/*ROTATE*/];
|
||||
x = frames[i + 2/*X*/];
|
||||
y = frames[i + 3/*Y*/];
|
||||
scaleX = frames[i + 4/*SCALEX*/];
|
||||
scaleY = frames[i + 5/*SCALEY*/];
|
||||
shearY = frames[i + 6/*SHEARY*/];
|
||||
let t = (time - before) / (frames[i + 7/*ENTRIES*/] - before);
|
||||
rotate += (frames[i + 7/*ENTRIES*/ + 1/*ROTATE*/] - rotate) * t;
|
||||
x += (frames[i + 7/*ENTRIES*/ + 2/*X*/] - x) * t;
|
||||
y += (frames[i + 7/*ENTRIES*/ + 3/*Y*/] - y) * t;
|
||||
scaleX += (frames[i + 7/*ENTRIES*/ + 4/*SCALEX*/] - scaleX) * t;
|
||||
scaleY += (frames[i + 7/*ENTRIES*/ + 5/*SCALEY*/] - scaleY) * t;
|
||||
shearY += (frames[i + 7/*ENTRIES*/ + 6/*SHEARY*/] - shearY) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
rotate = frames[i + ROTATE];
|
||||
x = frames[i + X];
|
||||
y = frames[i + Y];
|
||||
scaleX = frames[i + SCALEX];
|
||||
scaleY = frames[i + SCALEY];
|
||||
shearY = frames[i + SHEARY];
|
||||
case 1/*STEPPED*/:
|
||||
rotate = frames[i + 1/*ROTATE*/];
|
||||
x = frames[i + 2/*X*/];
|
||||
y = frames[i + 3/*Y*/];
|
||||
scaleX = frames[i + 4/*SCALEX*/];
|
||||
scaleY = frames[i + 5/*SCALEY*/];
|
||||
shearY = frames[i + 6/*SHEARY*/];
|
||||
break;
|
||||
default:
|
||||
rotate = this.getBezierValue(time, i, ROTATE, curveType - BEZIER);
|
||||
x = this.getBezierValue(time, i, X, curveType + BEZIER_SIZE - BEZIER);
|
||||
y = this.getBezierValue(time, i, Y, curveType + BEZIER_SIZE * 2 - BEZIER);
|
||||
scaleX = this.getBezierValue(time, i, SCALEX, curveType + BEZIER_SIZE * 3 - BEZIER);
|
||||
scaleY = this.getBezierValue(time, i, SCALEY, curveType + BEZIER_SIZE * 4 - BEZIER);
|
||||
shearY = this.getBezierValue(time, i, SHEARY, curveType + BEZIER_SIZE * 5 - BEZIER);
|
||||
rotate = this.getBezierValue(time, i, 1/*ROTATE*/, curveType - 2/*BEZIER*/);
|
||||
x = this.getBezierValue(time, i, 2/*X*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
y = this.getBezierValue(time, i, 3/*Y*/, curveType + 18/*BEZIER_SIZE*/ * 2 - 2/*BEZIER*/);
|
||||
scaleX = this.getBezierValue(time, i, 4/*SCALEX*/, curveType + 18/*BEZIER_SIZE*/ * 3 - 2/*BEZIER*/);
|
||||
scaleY = this.getBezierValue(time, i, 5/*SCALEY*/, curveType + 18/*BEZIER_SIZE*/ * 4 - 2/*BEZIER*/);
|
||||
shearY = this.getBezierValue(time, i, 6/*SHEARY*/, curveType + 18/*BEZIER_SIZE*/ * 5 - 2/*BEZIER*/);
|
||||
}
|
||||
|
||||
if (blend == MixBlend.setup) {
|
||||
@ -2108,9 +2075,6 @@ module spine {
|
||||
/** Changes a transform constraint's {@link PathConstraint#getMixRotate()}, {@link PathConstraint#getMixX()}, and
|
||||
* {@link PathConstraint#getMixY()}. */
|
||||
export class PathConstraintMixTimeline extends CurveTimeline {
|
||||
static ENTRIES = 4;
|
||||
static ROTATE = 1; static X = 2; static Y = 3;
|
||||
|
||||
/** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
|
||||
pathConstraintIndex = 0;
|
||||
|
||||
@ -2122,16 +2086,16 @@ module spine {
|
||||
}
|
||||
|
||||
getFrameEntries () {
|
||||
return PathConstraintMixTimeline.ENTRIES;
|
||||
return 4/*ENTRIES*/;
|
||||
}
|
||||
|
||||
setFrame (frame: number, time: number, mixRotate: number, mixX: number, mixY: number) {
|
||||
let frames = this.frames;
|
||||
frame <<= 2;
|
||||
frames[frame] = time;
|
||||
frames[frame + PathConstraintMixTimeline.ROTATE] = mixRotate;
|
||||
frames[frame + PathConstraintMixTimeline.X] = mixX;
|
||||
frames[frame + PathConstraintMixTimeline.Y] = mixY;
|
||||
frames[frame + 1/*ROTATE*/] = mixRotate;
|
||||
frames[frame + 2/*X*/] = mixX;
|
||||
frames[frame + 3/*Y*/] = mixY;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
|
||||
@ -2155,28 +2119,28 @@ module spine {
|
||||
}
|
||||
|
||||
let rotate, x, y;
|
||||
let i = Timeline.search2(frames, time, PathConstraintMixTimeline.ENTRIES);
|
||||
let i = Timeline.search2(frames, time, 4/*ENTRIES*/);
|
||||
let curveType = this.curves[i >> 2];
|
||||
switch (curveType) {
|
||||
case LINEAR:
|
||||
case 0/*LINEAR*/:
|
||||
let before = frames[i];
|
||||
rotate = frames[i + PathConstraintMixTimeline.ROTATE];
|
||||
x = frames[i + PathConstraintMixTimeline.X];
|
||||
y = frames[i + PathConstraintMixTimeline.Y];
|
||||
let t = (time - before) / (frames[i + PathConstraintMixTimeline.ENTRIES] - before);
|
||||
rotate += (frames[i + PathConstraintMixTimeline.ENTRIES + PathConstraintMixTimeline.ROTATE] - rotate) * t;
|
||||
x += (frames[i + PathConstraintMixTimeline.ENTRIES + PathConstraintMixTimeline.X] - x) * t;
|
||||
y += (frames[i + PathConstraintMixTimeline.ENTRIES + PathConstraintMixTimeline.Y] - y) * t;
|
||||
rotate = frames[i + 1/*ROTATE*/];
|
||||
x = frames[i + 2/*X*/];
|
||||
y = frames[i + 3/*Y*/];
|
||||
let t = (time - before) / (frames[i + 4/*ENTRIES*/] - before);
|
||||
rotate += (frames[i + 4/*ENTRIES*/ + 1/*ROTATE*/] - rotate) * t;
|
||||
x += (frames[i + 4/*ENTRIES*/ + 2/*X*/] - x) * t;
|
||||
y += (frames[i + 4/*ENTRIES*/ + 3/*Y*/] - y) * t;
|
||||
break;
|
||||
case STEPPED:
|
||||
rotate = frames[i + PathConstraintMixTimeline.ROTATE];
|
||||
x = frames[i + PathConstraintMixTimeline.X];
|
||||
y = frames[i + PathConstraintMixTimeline.Y];
|
||||
case 1/*STEPPED*/:
|
||||
rotate = frames[i + 1/*ROTATE*/];
|
||||
x = frames[i + 2/*X*/];
|
||||
y = frames[i + 3/*Y*/];
|
||||
break;
|
||||
default:
|
||||
rotate = this.getBezierValue(time, i, PathConstraintMixTimeline.ROTATE, curveType - BEZIER);
|
||||
x = this.getBezierValue(time, i, PathConstraintMixTimeline.X, curveType + BEZIER_SIZE - BEZIER);
|
||||
y = this.getBezierValue(time, i, PathConstraintMixTimeline.Y, curveType + BEZIER_SIZE * 2 - BEZIER);
|
||||
rotate = this.getBezierValue(time, i, 1/*ROTATE*/, curveType - 2/*BEZIER*/);
|
||||
x = this.getBezierValue(time, i, 2/*X*/, curveType + 18/*BEZIER_SIZE*/ - 2/*BEZIER*/);
|
||||
y = this.getBezierValue(time, i, 3/*Y*/, curveType + 18/*BEZIER_SIZE*/ * 2 - 2/*BEZIER*/);
|
||||
}
|
||||
|
||||
if (blend == MixBlend.setup) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user