mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-03-26 22:49:01 +08:00
Merge remote-tracking branch 'origin/3.6-beta' into 3.6-beta
This commit is contained in:
NathanSweet
commit
c4268d4bfe
@ -15,6 +15,7 @@
|
||||
* Added two color tinting support, including `TwoColorTimeline` and additional fields on `Slot` and `SlotData`.
|
||||
* Added `PointAttachment`, additional method `newPointAttachment` in `AttachmentLoader` interface.
|
||||
* Added `ClippingAttachment`, additional method `newClippingAttachment` in `AttachmentLoader` interface.
|
||||
* `AnimationState#apply` returns boolean indicating if any timeline was applied or not.
|
||||
|
||||
### Starling
|
||||
* Fixed renderer to work with 3.6 changes.
|
||||
@ -42,6 +43,7 @@
|
||||
* Added macros to define typed dynamic arrays, see `Array.h/.c`
|
||||
* Added `spClippingAttachment` and respective enum.
|
||||
* Added `spSkeletonClipper` and `spTriangulator`, used to implement software clipping of attachments.
|
||||
* `AnimationState#apply` returns boolean indicating if any timeline was applied or not.
|
||||
|
||||
### Cocos2d-X
|
||||
* Fixed renderer to work with 3.6 changes
|
||||
@ -71,6 +73,8 @@
|
||||
## C#
|
||||
* **Breaking changes**
|
||||
* `MeshAttachment.parentMesh` is now a private field to enforce using the `.ParentMesh` setter property in external code. The `MeshAttachment.ParentMesh` property is an appropriate replacement wherever `.parentMesh` was used.
|
||||
* **Additions**
|
||||
* `AnimationState#apply` returns boolean indicating if any timeline was applied or not.
|
||||
|
||||
### Unity
|
||||
* Refactored renderer to work with new 3.6 features.
|
||||
@ -127,6 +131,7 @@
|
||||
* Added `PointAttachment`, additional method `newPointAttachment` in `AttachmentLoader` interface.
|
||||
* Added `ClippingAttachment`, additional method `newClippingAttachment` in `AttachmentLoader` interface.
|
||||
* Added `SkeletonClipper` and `Triangulator`, used to implement software clipping of attachments.
|
||||
* `AnimationState#apply` returns boolean indicating if any timeline was applied or not.
|
||||
|
||||
### libGDX
|
||||
* Fixed renderer to work with 3.6 changes
|
||||
@ -147,6 +152,7 @@
|
||||
* Added support for local and relative transform constraint calculation, including additional fields in `TransformConstraintData`
|
||||
* Added `ClippingAttachment`, additional method `newClippingAttachment` in `AttachmentLoader` interface.
|
||||
* Added `SkeletonClipper` and `Triangulator`, used to implement software clipping of attachments.
|
||||
* `AnimationState#apply` returns boolean indicating if any timeline was applied or not.
|
||||
|
||||
### Love2D
|
||||
* Fixed renderer to work with 3.6 changes
|
||||
@ -171,6 +177,7 @@
|
||||
* Added `PointAttachment`, additional method `newPointAttachment` in `AttachmentLoader` interface.
|
||||
* Added `ClippingAttachment`, additional method `newClippingAttachment` in `AttachmentLoader` interface.
|
||||
* Added `SkeletonClipper` and `Triangulator`, used to implement software clipping of attachments.
|
||||
* `AnimationState#apply` returns boolean indicating if any timeline was applied or not.
|
||||
|
||||
### WebGL backend
|
||||
* Fixed WebGL context loss
|
||||
|
||||
Binary file not shown.
@ -147,15 +147,17 @@ package spine.animation {
|
||||
return false;
|
||||
}
|
||||
|
||||
public function apply(skeleton : Skeleton) : void {
|
||||
public function apply(skeleton : Skeleton) : Boolean {
|
||||
if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
|
||||
if (animationsChanged) _animationsChanged();
|
||||
|
||||
var events : Vector.<Event> = this.events;
|
||||
var applied : Boolean = false;
|
||||
|
||||
for (var i : int = 0, n : int = tracks.length; i < n; i++) {
|
||||
var current : TrackEntry = tracks[i];
|
||||
if (current == null || current.delay > 0) continue;
|
||||
applied = true;
|
||||
|
||||
// Apply mixing from entries first.
|
||||
var mix : Number = current.alpha;
|
||||
@ -194,6 +196,7 @@ package spine.animation {
|
||||
}
|
||||
|
||||
queue.drain();
|
||||
return applied;
|
||||
}
|
||||
|
||||
private function applyMixingFrom(to : TrackEntry, skeleton : Skeleton) : Number {
|
||||
|
||||
@ -72,7 +72,7 @@ package spine.animation {
|
||||
var frameVertices : Vector.<Vector.<Number>> = this.frameVertices;
|
||||
var vertexCount : int = frameVertices[0].length;
|
||||
|
||||
if (verticesArray.length != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
|
||||
if (verticesArray.length != vertexCount && !setupPose) alpha = 1; // Don't mix from uninitialized slot vertices.
|
||||
verticesArray.length = vertexCount;
|
||||
var vertices : Vector.<Number> = verticesArray;
|
||||
|
||||
|
||||
@ -120,7 +120,7 @@ spAnimationState* spAnimationState_create (spAnimationStateData* data);
|
||||
void spAnimationState_dispose (spAnimationState* self);
|
||||
|
||||
void spAnimationState_update (spAnimationState* self, float delta);
|
||||
void spAnimationState_apply (spAnimationState* self, struct spSkeleton* skeleton);
|
||||
int /**bool**/ spAnimationState_apply (spAnimationState* self, struct spSkeleton* skeleton);
|
||||
|
||||
void spAnimationState_clearTracks (spAnimationState* self);
|
||||
void spAnimationState_clearTrack (spAnimationState* self, int trackIndex);
|
||||
|
||||
@ -806,7 +806,7 @@ void _spDeformTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton,
|
||||
slot->attachmentVerticesCapacity = vertexCount;
|
||||
}
|
||||
}
|
||||
if (slot->attachmentVerticesCount != vertexCount) alpha = 1; /* Don't mix from uninitialized slot vertices. */
|
||||
if (slot->attachmentVerticesCount != vertexCount && !setupPose) alpha = 1; /* Don't mix from uninitialized slot vertices. */
|
||||
slot->attachmentVerticesCount = vertexCount;
|
||||
|
||||
frameVertices = self->frameVertices;
|
||||
|
||||
@ -327,7 +327,7 @@ int /*boolean*/ _spAnimationState_updateMixingFrom (spAnimationState* self, spTr
|
||||
return 0;
|
||||
}
|
||||
|
||||
void spAnimationState_apply (spAnimationState* self, spSkeleton* skeleton) {
|
||||
int spAnimationState_apply (spAnimationState* self, spSkeleton* skeleton) {
|
||||
_spAnimationState* internal = SUB_CAST(_spAnimationState, self);
|
||||
spTrackEntry* current;
|
||||
int i, ii, n;
|
||||
@ -337,6 +337,7 @@ void spAnimationState_apply (spAnimationState* self, spSkeleton* skeleton) {
|
||||
int /*boolean*/ firstFrame;
|
||||
float* timelinesRotation;
|
||||
spTimeline* timeline;
|
||||
int applied = 0;
|
||||
|
||||
if (internal->animationsChanged) _spAnimationState_animationsChanged(self);
|
||||
|
||||
@ -344,6 +345,7 @@ void spAnimationState_apply (spAnimationState* self, spSkeleton* skeleton) {
|
||||
float mix;
|
||||
current = self->tracks[i];
|
||||
if (!current || current->delay > 0) continue;
|
||||
applied = -1;
|
||||
|
||||
/* Apply mixing from entries first. */
|
||||
mix = current->alpha;
|
||||
@ -381,6 +383,7 @@ void spAnimationState_apply (spAnimationState* self, spSkeleton* skeleton) {
|
||||
}
|
||||
|
||||
_spEventQueue_drain(internal->queue);
|
||||
return applied;
|
||||
}
|
||||
|
||||
float _spAnimationState_applyMixingFrom (spAnimationState* self, spTrackEntry* to, spSkeleton* skeleton) {
|
||||
|
||||
@ -773,7 +773,7 @@ namespace Spine {
|
||||
float[][] frameVertices = this.frameVertices;
|
||||
int vertexCount = frameVertices[0].Length;
|
||||
|
||||
if (verticesArray.Count != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
|
||||
if (verticesArray.Count != vertexCount && !setupPose) alpha = 1; // Don't mix from uninitialized slot vertices.
|
||||
// verticesArray.SetSize(vertexCount) // Ensure size and preemptively set count.
|
||||
if (verticesArray.Capacity < vertexCount) verticesArray.Capacity = vertexCount;
|
||||
verticesArray.Count = vertexCount;
|
||||
|
||||
@ -159,16 +159,18 @@ namespace Spine {
|
||||
/// <summary>
|
||||
/// 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.</summary>
|
||||
public void Apply (Skeleton skeleton) {
|
||||
public bool Apply (Skeleton skeleton) {
|
||||
if (skeleton == null) throw new ArgumentNullException("skeleton", "skeleton cannot be null.");
|
||||
if (animationsChanged) AnimationsChanged();
|
||||
|
||||
var events = this.events;
|
||||
|
||||
bool applied = false;
|
||||
var tracksItems = tracks.Items;
|
||||
for (int i = 0, m = tracks.Count; i < m; i++) {
|
||||
TrackEntry current = tracksItems[i];
|
||||
if (current == null || current.delay > 0) continue;
|
||||
applied = true;
|
||||
|
||||
// Apply mixing from entries first.
|
||||
float mix = current.alpha;
|
||||
@ -210,6 +212,7 @@ namespace Spine {
|
||||
}
|
||||
|
||||
queue.Drain();
|
||||
return applied;
|
||||
}
|
||||
|
||||
private float ApplyMixingFrom (TrackEntry to, Skeleton skeleton) {
|
||||
|
||||
@ -52,8 +52,8 @@ namespace Spine {
|
||||
public float B { get { return b; } set { b = value; } }
|
||||
public float A { get { return a; } set { a = value; } }
|
||||
|
||||
public String Path { get; set; }
|
||||
public Object RendererObject { get; set; }
|
||||
public string Path { get; set; }
|
||||
public object RendererObject; //public Object RendererObject { get; set; }
|
||||
public float RegionU { get; set; }
|
||||
public float RegionV { get; set; }
|
||||
public float RegionU2 { get; set; }
|
||||
|
||||
@ -46,8 +46,8 @@ namespace Spine {
|
||||
: base(name) {
|
||||
}
|
||||
|
||||
public void ComputeWorldPosition (Bone bone, float x, float y, out float ox, out float oy) {
|
||||
bone.LocalToWorld(x, y, out ox, out oy);
|
||||
public void ComputeWorldPosition (Bone bone, out float ox, out float oy) {
|
||||
bone.LocalToWorld(this.x, this.y, out ox, out oy);
|
||||
}
|
||||
|
||||
public float ComputeWorldRotation (Bone bone) {
|
||||
|
||||
@ -61,7 +61,7 @@ namespace Spine {
|
||||
public float A { get { return a; } set { a = value; } }
|
||||
|
||||
public string Path { get; set; }
|
||||
public object RendererObject { get; set; }
|
||||
public object RendererObject; //public object RendererObject { get; set; }
|
||||
public float RegionOffsetX { get { return regionOffsetX; } set { regionOffsetX = value; } }
|
||||
public float RegionOffsetY { get { return regionOffsetY; } set { regionOffsetY = value; } } // Pixels stripped from the bottom left, unrotated.
|
||||
public float RegionWidth { get { return regionWidth; } set { regionWidth = value; } }
|
||||
|
||||
@ -57,7 +57,7 @@ namespace Spine {
|
||||
/// <param name="stride">The number of <paramref name="worldVertices"/> entries between the value pairs written.</param>
|
||||
public void ComputeWorldVertices (Slot slot, int start, int count, float[] worldVertices, int offset, int stride = 2) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
Skeleton skeleton = slot.Skeleton;
|
||||
Skeleton skeleton = slot.bone.skeleton;
|
||||
var deformArray = slot.attachmentVertices;
|
||||
float[] vertices = this.vertices;
|
||||
int[] bones = this.bones;
|
||||
|
||||
@ -183,7 +183,7 @@ namespace Spine {
|
||||
float maxAngle = 0, maxX = l1 + a, maxDist = maxX * maxX, maxY = 0;
|
||||
c = -a * l1 / (aa - bb);
|
||||
if (c >= -1 && c <= 1) {
|
||||
float angle = (float)Math.Acos(c);
|
||||
c = (float)Math.Acos(c);
|
||||
x = a * (float)Math.Cos(c) + l1;
|
||||
y = b * (float)Math.Sin(c);
|
||||
d = x * x + y * y;
|
||||
|
||||
@ -769,7 +769,7 @@ function Animation.DeformTimeline.new (frameCount)
|
||||
local frameVertices = self.frameVertices
|
||||
local vertexCount = #(frameVertices[0])
|
||||
|
||||
if (#verticesArray ~= vertexCount) then alpha = 1 end -- Don't mix from uninitialized slot vertices.
|
||||
if (#verticesArray ~= vertexCount and not setupPose) then alpha = 1 end -- Don't mix from uninitialized slot vertices.
|
||||
local vertices = utils.setArraySize(verticesArray, vertexCount)
|
||||
|
||||
if time >= frames[zlen(frames) - 1] then -- Time is after last frame.
|
||||
|
||||
@ -366,9 +366,11 @@ function AnimationState:apply (skeleton)
|
||||
local events = self.events
|
||||
local tracks = self.tracks
|
||||
local queue = self.queue
|
||||
local applied = false
|
||||
|
||||
for i,current in pairs(tracks) do
|
||||
if not (current == nil or current.delay > 0) then
|
||||
applied = true
|
||||
-- Apply mixing from entries first.
|
||||
local mix = current.alpha
|
||||
if current.mixingFrom then
|
||||
@ -407,6 +409,7 @@ function AnimationState:apply (skeleton)
|
||||
end
|
||||
|
||||
queue:drain()
|
||||
return applied
|
||||
end
|
||||
|
||||
function AnimationState:applyMixingFrom (to, skeleton)
|
||||
|
||||
Binary file not shown.
Binary file not shown.
592
spine-ts/build/spine-all.d.ts
vendored
592
spine-ts/build/spine-all.d.ts
vendored
@ -1,3 +1,97 @@
|
||||
declare module spine {
|
||||
class AssetManager implements Disposable {
|
||||
private pathPrefix;
|
||||
private textureLoader;
|
||||
private assets;
|
||||
private errors;
|
||||
private toLoad;
|
||||
private loaded;
|
||||
constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
|
||||
loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
get(path: string): any;
|
||||
remove(path: string): void;
|
||||
removeAll(): void;
|
||||
isLoadingComplete(): boolean;
|
||||
getToLoad(): number;
|
||||
getLoaded(): number;
|
||||
dispose(): void;
|
||||
hasErrors(): boolean;
|
||||
getErrors(): Map<string>;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(pathPrefix?: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Texture {
|
||||
protected _image: HTMLImageElement;
|
||||
constructor(image: HTMLImageElement);
|
||||
getImage(): HTMLImageElement;
|
||||
abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
abstract dispose(): void;
|
||||
static filterFromString(text: string): TextureFilter;
|
||||
static wrapFromString(text: string): TextureWrap;
|
||||
}
|
||||
enum TextureFilter {
|
||||
Nearest = 9728,
|
||||
Linear = 9729,
|
||||
MipMap = 9987,
|
||||
MipMapNearestNearest = 9984,
|
||||
MipMapLinearNearest = 9985,
|
||||
MipMapNearestLinear = 9986,
|
||||
MipMapLinearLinear = 9987,
|
||||
}
|
||||
enum TextureWrap {
|
||||
MirroredRepeat = 33648,
|
||||
ClampToEdge = 33071,
|
||||
Repeat = 10497,
|
||||
}
|
||||
class TextureRegion {
|
||||
renderObject: any;
|
||||
u: number;
|
||||
v: number;
|
||||
u2: number;
|
||||
v2: number;
|
||||
width: number;
|
||||
height: number;
|
||||
rotate: boolean;
|
||||
offsetX: number;
|
||||
offsetY: number;
|
||||
originalWidth: number;
|
||||
originalHeight: number;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class CanvasTexture extends Texture {
|
||||
constructor(image: HTMLImageElement);
|
||||
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
dispose(): void;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class SkeletonRenderer {
|
||||
static QUAD_TRIANGLES: number[];
|
||||
static VERTEX_SIZE: number;
|
||||
private ctx;
|
||||
triangleRendering: boolean;
|
||||
debugRendering: boolean;
|
||||
private vertices;
|
||||
private tempColor;
|
||||
constructor(context: CanvasRenderingContext2D);
|
||||
draw(skeleton: Skeleton): void;
|
||||
private drawImages(skeleton);
|
||||
private drawTriangles(skeleton);
|
||||
private drawTriangle(img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
|
||||
private computeRegionVertices(slot, region, pma);
|
||||
private computeMeshVertices(slot, mesh, pma);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class Animation {
|
||||
name: string;
|
||||
@ -245,7 +339,7 @@ declare module spine {
|
||||
constructor(data: AnimationStateData);
|
||||
update(delta: number): void;
|
||||
updateMixingFrom(to: TrackEntry, delta: number): boolean;
|
||||
apply(skeleton: Skeleton): void;
|
||||
apply(skeleton: Skeleton): boolean;
|
||||
applyMixingFrom(to: TrackEntry, skeleton: Skeleton): number;
|
||||
applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, setupPose: boolean, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
|
||||
queueEvents(entry: TrackEntry, animationTime: number): void;
|
||||
@ -355,29 +449,6 @@ declare module spine {
|
||||
getMix(from: Animation, to: Animation): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class AssetManager implements Disposable {
|
||||
private pathPrefix;
|
||||
private textureLoader;
|
||||
private assets;
|
||||
private errors;
|
||||
private toLoad;
|
||||
private loaded;
|
||||
constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
|
||||
loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
get(path: string): any;
|
||||
remove(path: string): void;
|
||||
removeAll(): void;
|
||||
isLoadingComplete(): boolean;
|
||||
getToLoad(): number;
|
||||
getLoaded(): number;
|
||||
dispose(): void;
|
||||
hasErrors(): boolean;
|
||||
getErrors(): Map<string>;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class AtlasAttachmentLoader implements AttachmentLoader {
|
||||
atlas: TextureAtlas;
|
||||
@ -390,6 +461,154 @@ declare module spine {
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum BlendMode {
|
||||
Normal = 0,
|
||||
@ -775,46 +994,6 @@ declare module spine {
|
||||
constructor(index: number, name: string, boneData: BoneData);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Texture {
|
||||
protected _image: HTMLImageElement;
|
||||
constructor(image: HTMLImageElement);
|
||||
getImage(): HTMLImageElement;
|
||||
abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
abstract dispose(): void;
|
||||
static filterFromString(text: string): TextureFilter;
|
||||
static wrapFromString(text: string): TextureWrap;
|
||||
}
|
||||
enum TextureFilter {
|
||||
Nearest = 9728,
|
||||
Linear = 9729,
|
||||
MipMap = 9987,
|
||||
MipMapNearestNearest = 9984,
|
||||
MipMapLinearNearest = 9985,
|
||||
MipMapNearestLinear = 9986,
|
||||
MipMapLinearLinear = 9987,
|
||||
}
|
||||
enum TextureWrap {
|
||||
MirroredRepeat = 33648,
|
||||
ClampToEdge = 33071,
|
||||
Repeat = 10497,
|
||||
}
|
||||
class TextureRegion {
|
||||
renderObject: any;
|
||||
u: number;
|
||||
v: number;
|
||||
u2: number;
|
||||
v2: number;
|
||||
width: number;
|
||||
height: number;
|
||||
rotate: boolean;
|
||||
offsetX: number;
|
||||
offsetY: number;
|
||||
originalWidth: number;
|
||||
originalHeight: number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class TextureAtlas implements Disposable {
|
||||
pages: TextureAtlasPage[];
|
||||
@ -1010,183 +1189,51 @@ declare module spine {
|
||||
getMean(): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
declare module spine.threejs {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(pathPrefix?: string);
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class CanvasTexture extends Texture {
|
||||
declare module spine.threejs {
|
||||
class MeshBatcher {
|
||||
mesh: THREE.Mesh;
|
||||
private static VERTEX_SIZE;
|
||||
private vertexBuffer;
|
||||
private vertices;
|
||||
private verticesLength;
|
||||
private indices;
|
||||
private indicesLength;
|
||||
constructor(mesh: THREE.Mesh, maxVertices?: number);
|
||||
begin(): void;
|
||||
batch(vertices: ArrayLike<number>, verticesLength: number, indices: ArrayLike<number>, indicesLength: number, z?: number): void;
|
||||
end(): void;
|
||||
}
|
||||
}
|
||||
declare module spine.threejs {
|
||||
class SkeletonMesh extends THREE.Mesh {
|
||||
skeleton: Skeleton;
|
||||
state: AnimationState;
|
||||
zOffset: number;
|
||||
private batcher;
|
||||
private clipper;
|
||||
static QUAD_TRIANGLES: number[];
|
||||
static VERTEX_SIZE: number;
|
||||
private vertices;
|
||||
private tempColor;
|
||||
constructor(skeletonData: SkeletonData);
|
||||
update(deltaTime: number): void;
|
||||
private updateGeometry();
|
||||
}
|
||||
}
|
||||
declare module spine.threejs {
|
||||
class ThreeJsTexture extends Texture {
|
||||
texture: THREE.Texture;
|
||||
constructor(image: HTMLImageElement);
|
||||
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
dispose(): void;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class SkeletonRenderer {
|
||||
static QUAD_TRIANGLES: number[];
|
||||
static VERTEX_SIZE: number;
|
||||
private ctx;
|
||||
triangleRendering: boolean;
|
||||
debugRendering: boolean;
|
||||
private vertices;
|
||||
private tempColor;
|
||||
constructor(context: CanvasRenderingContext2D);
|
||||
draw(skeleton: Skeleton): void;
|
||||
private drawImages(skeleton);
|
||||
private drawTriangles(skeleton);
|
||||
private drawTriangle(img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
|
||||
private computeRegionVertices(slot, region, pma);
|
||||
private computeMeshVertices(slot, mesh, pma);
|
||||
static toThreeJsTextureFilter(filter: TextureFilter): THREE.TextureFilter;
|
||||
static toThreeJsTextureWrap(wrap: TextureWrap): THREE.Wrapping;
|
||||
}
|
||||
}
|
||||
declare module spine.webgl {
|
||||
@ -1280,22 +1327,22 @@ declare module spine.webgl {
|
||||
}
|
||||
}
|
||||
declare module spine.webgl {
|
||||
const M00 = 0;
|
||||
const M01 = 4;
|
||||
const M02 = 8;
|
||||
const M03 = 12;
|
||||
const M10 = 1;
|
||||
const M11 = 5;
|
||||
const M12 = 9;
|
||||
const M13 = 13;
|
||||
const M20 = 2;
|
||||
const M21 = 6;
|
||||
const M22 = 10;
|
||||
const M23 = 14;
|
||||
const M30 = 3;
|
||||
const M31 = 7;
|
||||
const M32 = 11;
|
||||
const M33 = 15;
|
||||
const M00: number;
|
||||
const M01: number;
|
||||
const M02: number;
|
||||
const M03: number;
|
||||
const M10: number;
|
||||
const M11: number;
|
||||
const M12: number;
|
||||
const M13: number;
|
||||
const M20: number;
|
||||
const M21: number;
|
||||
const M22: number;
|
||||
const M23: number;
|
||||
const M30: number;
|
||||
const M31: number;
|
||||
const M32: number;
|
||||
const M33: number;
|
||||
class Matrix4 {
|
||||
temp: Float32Array;
|
||||
values: Float32Array;
|
||||
@ -1614,53 +1661,6 @@ declare module spine.webgl {
|
||||
static getSourceGLBlendMode(blendMode: BlendMode, premultipliedAlpha?: boolean): number;
|
||||
}
|
||||
}
|
||||
declare module spine.threejs {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(pathPrefix?: string);
|
||||
}
|
||||
}
|
||||
declare module spine.threejs {
|
||||
class MeshBatcher {
|
||||
mesh: THREE.Mesh;
|
||||
private static VERTEX_SIZE;
|
||||
private vertexBuffer;
|
||||
private vertices;
|
||||
private verticesLength;
|
||||
private indices;
|
||||
private indicesLength;
|
||||
constructor(mesh: THREE.Mesh, maxVertices?: number);
|
||||
begin(): void;
|
||||
batch(vertices: ArrayLike<number>, verticesLength: number, indices: ArrayLike<number>, indicesLength: number, z?: number): void;
|
||||
end(): void;
|
||||
}
|
||||
}
|
||||
declare module spine.threejs {
|
||||
class SkeletonMesh extends THREE.Mesh {
|
||||
skeleton: Skeleton;
|
||||
state: AnimationState;
|
||||
zOffset: number;
|
||||
private batcher;
|
||||
private clipper;
|
||||
static QUAD_TRIANGLES: number[];
|
||||
static VERTEX_SIZE: number;
|
||||
private vertices;
|
||||
private tempColor;
|
||||
constructor(skeletonData: SkeletonData);
|
||||
update(deltaTime: number): void;
|
||||
private updateGeometry();
|
||||
}
|
||||
}
|
||||
declare module spine.threejs {
|
||||
class ThreeJsTexture extends Texture {
|
||||
texture: THREE.Texture;
|
||||
constructor(image: HTMLImageElement);
|
||||
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
dispose(): void;
|
||||
static toThreeJsTextureFilter(filter: TextureFilter): THREE.TextureFilter;
|
||||
static toThreeJsTextureWrap(wrap: TextureWrap): THREE.Wrapping;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class SpineWidget {
|
||||
skeleton: Skeleton;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
486
spine-ts/build/spine-canvas.d.ts
vendored
486
spine-ts/build/spine-canvas.d.ts
vendored
@ -1,3 +1,97 @@
|
||||
declare module spine {
|
||||
class AssetManager implements Disposable {
|
||||
private pathPrefix;
|
||||
private textureLoader;
|
||||
private assets;
|
||||
private errors;
|
||||
private toLoad;
|
||||
private loaded;
|
||||
constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
|
||||
loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
get(path: string): any;
|
||||
remove(path: string): void;
|
||||
removeAll(): void;
|
||||
isLoadingComplete(): boolean;
|
||||
getToLoad(): number;
|
||||
getLoaded(): number;
|
||||
dispose(): void;
|
||||
hasErrors(): boolean;
|
||||
getErrors(): Map<string>;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(pathPrefix?: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Texture {
|
||||
protected _image: HTMLImageElement;
|
||||
constructor(image: HTMLImageElement);
|
||||
getImage(): HTMLImageElement;
|
||||
abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
abstract dispose(): void;
|
||||
static filterFromString(text: string): TextureFilter;
|
||||
static wrapFromString(text: string): TextureWrap;
|
||||
}
|
||||
enum TextureFilter {
|
||||
Nearest = 9728,
|
||||
Linear = 9729,
|
||||
MipMap = 9987,
|
||||
MipMapNearestNearest = 9984,
|
||||
MipMapLinearNearest = 9985,
|
||||
MipMapNearestLinear = 9986,
|
||||
MipMapLinearLinear = 9987,
|
||||
}
|
||||
enum TextureWrap {
|
||||
MirroredRepeat = 33648,
|
||||
ClampToEdge = 33071,
|
||||
Repeat = 10497,
|
||||
}
|
||||
class TextureRegion {
|
||||
renderObject: any;
|
||||
u: number;
|
||||
v: number;
|
||||
u2: number;
|
||||
v2: number;
|
||||
width: number;
|
||||
height: number;
|
||||
rotate: boolean;
|
||||
offsetX: number;
|
||||
offsetY: number;
|
||||
originalWidth: number;
|
||||
originalHeight: number;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class CanvasTexture extends Texture {
|
||||
constructor(image: HTMLImageElement);
|
||||
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
dispose(): void;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class SkeletonRenderer {
|
||||
static QUAD_TRIANGLES: number[];
|
||||
static VERTEX_SIZE: number;
|
||||
private ctx;
|
||||
triangleRendering: boolean;
|
||||
debugRendering: boolean;
|
||||
private vertices;
|
||||
private tempColor;
|
||||
constructor(context: CanvasRenderingContext2D);
|
||||
draw(skeleton: Skeleton): void;
|
||||
private drawImages(skeleton);
|
||||
private drawTriangles(skeleton);
|
||||
private drawTriangle(img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
|
||||
private computeRegionVertices(slot, region, pma);
|
||||
private computeMeshVertices(slot, mesh, pma);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class Animation {
|
||||
name: string;
|
||||
@ -245,7 +339,7 @@ declare module spine {
|
||||
constructor(data: AnimationStateData);
|
||||
update(delta: number): void;
|
||||
updateMixingFrom(to: TrackEntry, delta: number): boolean;
|
||||
apply(skeleton: Skeleton): void;
|
||||
apply(skeleton: Skeleton): boolean;
|
||||
applyMixingFrom(to: TrackEntry, skeleton: Skeleton): number;
|
||||
applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, setupPose: boolean, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
|
||||
queueEvents(entry: TrackEntry, animationTime: number): void;
|
||||
@ -355,29 +449,6 @@ declare module spine {
|
||||
getMix(from: Animation, to: Animation): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class AssetManager implements Disposable {
|
||||
private pathPrefix;
|
||||
private textureLoader;
|
||||
private assets;
|
||||
private errors;
|
||||
private toLoad;
|
||||
private loaded;
|
||||
constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
|
||||
loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
|
||||
get(path: string): any;
|
||||
remove(path: string): void;
|
||||
removeAll(): void;
|
||||
isLoadingComplete(): boolean;
|
||||
getToLoad(): number;
|
||||
getLoaded(): number;
|
||||
dispose(): void;
|
||||
hasErrors(): boolean;
|
||||
getErrors(): Map<string>;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class AtlasAttachmentLoader implements AttachmentLoader {
|
||||
atlas: TextureAtlas;
|
||||
@ -390,6 +461,154 @@ declare module spine {
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum BlendMode {
|
||||
Normal = 0,
|
||||
@ -775,46 +994,6 @@ declare module spine {
|
||||
constructor(index: number, name: string, boneData: BoneData);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Texture {
|
||||
protected _image: HTMLImageElement;
|
||||
constructor(image: HTMLImageElement);
|
||||
getImage(): HTMLImageElement;
|
||||
abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
abstract dispose(): void;
|
||||
static filterFromString(text: string): TextureFilter;
|
||||
static wrapFromString(text: string): TextureWrap;
|
||||
}
|
||||
enum TextureFilter {
|
||||
Nearest = 9728,
|
||||
Linear = 9729,
|
||||
MipMap = 9987,
|
||||
MipMapNearestNearest = 9984,
|
||||
MipMapLinearNearest = 9985,
|
||||
MipMapNearestLinear = 9986,
|
||||
MipMapLinearLinear = 9987,
|
||||
}
|
||||
enum TextureWrap {
|
||||
MirroredRepeat = 33648,
|
||||
ClampToEdge = 33071,
|
||||
Repeat = 10497,
|
||||
}
|
||||
class TextureRegion {
|
||||
renderObject: any;
|
||||
u: number;
|
||||
v: number;
|
||||
u2: number;
|
||||
v2: number;
|
||||
width: number;
|
||||
height: number;
|
||||
rotate: boolean;
|
||||
offsetX: number;
|
||||
offsetY: number;
|
||||
originalWidth: number;
|
||||
originalHeight: number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class TextureAtlas implements Disposable {
|
||||
pages: TextureAtlasPage[];
|
||||
@ -1010,182 +1189,3 @@ declare module spine {
|
||||
getMean(): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(pathPrefix?: string);
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class CanvasTexture extends Texture {
|
||||
constructor(image: HTMLImageElement);
|
||||
setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
|
||||
setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
|
||||
dispose(): void;
|
||||
}
|
||||
}
|
||||
declare module spine.canvas {
|
||||
class SkeletonRenderer {
|
||||
static QUAD_TRIANGLES: number[];
|
||||
static VERTEX_SIZE: number;
|
||||
private ctx;
|
||||
triangleRendering: boolean;
|
||||
debugRendering: boolean;
|
||||
private vertices;
|
||||
private tempColor;
|
||||
constructor(context: CanvasRenderingContext2D);
|
||||
draw(skeleton: Skeleton): void;
|
||||
private drawImages(skeleton);
|
||||
private drawTriangles(skeleton);
|
||||
private drawTriangle(img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
|
||||
private computeRegionVertices(slot, region, pma);
|
||||
private computeMeshVertices(slot, mesh, pma);
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
298
spine-ts/build/spine-core.d.ts
vendored
298
spine-ts/build/spine-core.d.ts
vendored
@ -245,7 +245,7 @@ declare module spine {
|
||||
constructor(data: AnimationStateData);
|
||||
update(delta: number): void;
|
||||
updateMixingFrom(to: TrackEntry, delta: number): boolean;
|
||||
apply(skeleton: Skeleton): void;
|
||||
apply(skeleton: Skeleton): boolean;
|
||||
applyMixingFrom(to: TrackEntry, skeleton: Skeleton): number;
|
||||
applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, setupPose: boolean, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
|
||||
queueEvents(entry: TrackEntry, animationTime: number): void;
|
||||
@ -390,6 +390,154 @@ declare module spine {
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum BlendMode {
|
||||
Normal = 0,
|
||||
@ -1010,151 +1158,3 @@ declare module spine {
|
||||
getMean(): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
298
spine-ts/build/spine-threejs.d.ts
vendored
298
spine-ts/build/spine-threejs.d.ts
vendored
@ -245,7 +245,7 @@ declare module spine {
|
||||
constructor(data: AnimationStateData);
|
||||
update(delta: number): void;
|
||||
updateMixingFrom(to: TrackEntry, delta: number): boolean;
|
||||
apply(skeleton: Skeleton): void;
|
||||
apply(skeleton: Skeleton): boolean;
|
||||
applyMixingFrom(to: TrackEntry, skeleton: Skeleton): number;
|
||||
applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, setupPose: boolean, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
|
||||
queueEvents(entry: TrackEntry, animationTime: number): void;
|
||||
@ -390,6 +390,154 @@ declare module spine {
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum BlendMode {
|
||||
Normal = 0,
|
||||
@ -1010,154 +1158,6 @@ declare module spine {
|
||||
getMean(): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine.threejs {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(pathPrefix?: string);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
330
spine-ts/build/spine-webgl.d.ts
vendored
330
spine-ts/build/spine-webgl.d.ts
vendored
@ -245,7 +245,7 @@ declare module spine {
|
||||
constructor(data: AnimationStateData);
|
||||
update(delta: number): void;
|
||||
updateMixingFrom(to: TrackEntry, delta: number): boolean;
|
||||
apply(skeleton: Skeleton): void;
|
||||
apply(skeleton: Skeleton): boolean;
|
||||
applyMixingFrom(to: TrackEntry, skeleton: Skeleton): number;
|
||||
applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, setupPose: boolean, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
|
||||
queueEvents(entry: TrackEntry, animationTime: number): void;
|
||||
@ -390,6 +390,154 @@ declare module spine {
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum BlendMode {
|
||||
Normal = 0,
|
||||
@ -1010,154 +1158,6 @@ declare module spine {
|
||||
getMean(): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine.webgl {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string);
|
||||
@ -1249,22 +1249,22 @@ declare module spine.webgl {
|
||||
}
|
||||
}
|
||||
declare module spine.webgl {
|
||||
const M00 = 0;
|
||||
const M01 = 4;
|
||||
const M02 = 8;
|
||||
const M03 = 12;
|
||||
const M10 = 1;
|
||||
const M11 = 5;
|
||||
const M12 = 9;
|
||||
const M13 = 13;
|
||||
const M20 = 2;
|
||||
const M21 = 6;
|
||||
const M22 = 10;
|
||||
const M23 = 14;
|
||||
const M30 = 3;
|
||||
const M31 = 7;
|
||||
const M32 = 11;
|
||||
const M33 = 15;
|
||||
const M00: number;
|
||||
const M01: number;
|
||||
const M02: number;
|
||||
const M03: number;
|
||||
const M10: number;
|
||||
const M11: number;
|
||||
const M12: number;
|
||||
const M13: number;
|
||||
const M20: number;
|
||||
const M21: number;
|
||||
const M22: number;
|
||||
const M23: number;
|
||||
const M30: number;
|
||||
const M31: number;
|
||||
const M32: number;
|
||||
const M33: number;
|
||||
class Matrix4 {
|
||||
temp: Float32Array;
|
||||
values: Float32Array;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
330
spine-ts/build/spine-widget.d.ts
vendored
330
spine-ts/build/spine-widget.d.ts
vendored
@ -245,7 +245,7 @@ declare module spine {
|
||||
constructor(data: AnimationStateData);
|
||||
update(delta: number): void;
|
||||
updateMixingFrom(to: TrackEntry, delta: number): boolean;
|
||||
apply(skeleton: Skeleton): void;
|
||||
apply(skeleton: Skeleton): boolean;
|
||||
applyMixingFrom(to: TrackEntry, skeleton: Skeleton): number;
|
||||
applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, setupPose: boolean, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
|
||||
queueEvents(entry: TrackEntry, animationTime: number): void;
|
||||
@ -390,6 +390,154 @@ declare module spine {
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum BlendMode {
|
||||
Normal = 0,
|
||||
@ -1010,154 +1158,6 @@ declare module spine {
|
||||
getMean(): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
abstract class Attachment {
|
||||
name: string;
|
||||
constructor(name: string);
|
||||
}
|
||||
abstract class VertexAttachment extends Attachment {
|
||||
bones: Array<number>;
|
||||
vertices: ArrayLike<number>;
|
||||
worldVerticesLength: number;
|
||||
constructor(name: string);
|
||||
computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
interface AttachmentLoader {
|
||||
newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
|
||||
newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
|
||||
newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
|
||||
newPathAttachment(skin: Skin, name: string): PathAttachment;
|
||||
newPointAttachment(skin: Skin, name: string): PointAttachment;
|
||||
newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
enum AttachmentType {
|
||||
Region = 0,
|
||||
BoundingBox = 1,
|
||||
Mesh = 2,
|
||||
LinkedMesh = 3,
|
||||
Path = 4,
|
||||
Point = 5,
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class BoundingBoxAttachment extends VertexAttachment {
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class ClippingAttachment extends VertexAttachment {
|
||||
endSlot: SlotData;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class MeshAttachment extends VertexAttachment {
|
||||
region: TextureRegion;
|
||||
path: string;
|
||||
regionUVs: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
triangles: Array<number>;
|
||||
color: Color;
|
||||
hullLength: number;
|
||||
private parentMesh;
|
||||
inheritDeform: boolean;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateUVs(): void;
|
||||
applyDeform(sourceAttachment: VertexAttachment): boolean;
|
||||
getParentMesh(): MeshAttachment;
|
||||
setParentMesh(parentMesh: MeshAttachment): void;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PathAttachment extends VertexAttachment {
|
||||
lengths: Array<number>;
|
||||
closed: boolean;
|
||||
constantSpeed: boolean;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class PointAttachment extends VertexAttachment {
|
||||
x: number;
|
||||
y: number;
|
||||
rotation: number;
|
||||
color: Color;
|
||||
constructor(name: string);
|
||||
computeWorldPosition(bone: Bone, point: Vector2): Vector2;
|
||||
computeWorldRotation(bone: Bone): number;
|
||||
}
|
||||
}
|
||||
declare module spine {
|
||||
class RegionAttachment extends Attachment {
|
||||
static OX1: number;
|
||||
static OY1: number;
|
||||
static OX2: number;
|
||||
static OY2: number;
|
||||
static OX3: number;
|
||||
static OY3: number;
|
||||
static OX4: number;
|
||||
static OY4: number;
|
||||
static X1: number;
|
||||
static Y1: number;
|
||||
static C1R: number;
|
||||
static C1G: number;
|
||||
static C1B: number;
|
||||
static C1A: number;
|
||||
static U1: number;
|
||||
static V1: number;
|
||||
static X2: number;
|
||||
static Y2: number;
|
||||
static C2R: number;
|
||||
static C2G: number;
|
||||
static C2B: number;
|
||||
static C2A: number;
|
||||
static U2: number;
|
||||
static V2: number;
|
||||
static X3: number;
|
||||
static Y3: number;
|
||||
static C3R: number;
|
||||
static C3G: number;
|
||||
static C3B: number;
|
||||
static C3A: number;
|
||||
static U3: number;
|
||||
static V3: number;
|
||||
static X4: number;
|
||||
static Y4: number;
|
||||
static C4R: number;
|
||||
static C4G: number;
|
||||
static C4B: number;
|
||||
static C4A: number;
|
||||
static U4: number;
|
||||
static V4: number;
|
||||
x: number;
|
||||
y: number;
|
||||
scaleX: number;
|
||||
scaleY: number;
|
||||
rotation: number;
|
||||
width: number;
|
||||
height: number;
|
||||
color: Color;
|
||||
path: string;
|
||||
rendererObject: any;
|
||||
region: TextureRegion;
|
||||
offset: ArrayLike<number>;
|
||||
uvs: ArrayLike<number>;
|
||||
tempColor: Color;
|
||||
constructor(name: string);
|
||||
updateOffset(): void;
|
||||
setRegion(region: TextureRegion): void;
|
||||
computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
|
||||
}
|
||||
}
|
||||
declare module spine.webgl {
|
||||
class AssetManager extends spine.AssetManager {
|
||||
constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string);
|
||||
@ -1249,22 +1249,22 @@ declare module spine.webgl {
|
||||
}
|
||||
}
|
||||
declare module spine.webgl {
|
||||
const M00 = 0;
|
||||
const M01 = 4;
|
||||
const M02 = 8;
|
||||
const M03 = 12;
|
||||
const M10 = 1;
|
||||
const M11 = 5;
|
||||
const M12 = 9;
|
||||
const M13 = 13;
|
||||
const M20 = 2;
|
||||
const M21 = 6;
|
||||
const M22 = 10;
|
||||
const M23 = 14;
|
||||
const M30 = 3;
|
||||
const M31 = 7;
|
||||
const M32 = 11;
|
||||
const M33 = 15;
|
||||
const M00: number;
|
||||
const M01: number;
|
||||
const M02: number;
|
||||
const M03: number;
|
||||
const M10: number;
|
||||
const M11: number;
|
||||
const M12: number;
|
||||
const M13: number;
|
||||
const M20: number;
|
||||
const M21: number;
|
||||
const M22: number;
|
||||
const M23: number;
|
||||
const M30: number;
|
||||
const M31: number;
|
||||
const M32: number;
|
||||
const M33: number;
|
||||
class Matrix4 {
|
||||
temp: Float32Array;
|
||||
values: Float32Array;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
@ -667,7 +667,7 @@ module spine {
|
||||
let frameVertices = this.frameVertices;
|
||||
let vertexCount = frameVertices[0].length;
|
||||
|
||||
if (verticesArray.length != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
|
||||
if (verticesArray.length != vertexCount && !setupPose) alpha = 1; // Don't mix from uninitialized slot vertices.
|
||||
let vertices: Array<number> = Utils.setArraySize(verticesArray, vertexCount);
|
||||
|
||||
if (time >= frames[frames.length - 1]) { // Time is after last frame.
|
||||
|
||||
@ -131,16 +131,18 @@ module spine {
|
||||
return false;
|
||||
}
|
||||
|
||||
apply (skeleton: Skeleton) {
|
||||
apply (skeleton: Skeleton) : boolean {
|
||||
if (skeleton == null) throw new Error("skeleton cannot be null.");
|
||||
if (this.animationsChanged) this._animationsChanged();
|
||||
|
||||
let events = this.events;
|
||||
let tracks = this.tracks;
|
||||
let applied = false;
|
||||
|
||||
for (let i = 0, n = tracks.length; i < n; i++) {
|
||||
let current = tracks[i];
|
||||
if (current == null || current.delay > 0) continue;
|
||||
applied = true;
|
||||
|
||||
// Apply mixing from entries first.
|
||||
let mix = current.alpha;
|
||||
@ -179,6 +181,7 @@ module spine {
|
||||
}
|
||||
|
||||
this.queue.drain();
|
||||
return applied;
|
||||
}
|
||||
|
||||
applyMixingFrom (to: TrackEntry, skeleton: Skeleton) {
|
||||
@ -206,7 +209,7 @@ module spine {
|
||||
let timelinesRotation = from.timelinesRotation;
|
||||
|
||||
let first = false;
|
||||
let alphaDip = from.alpha * to.interruptAlpha, alphaMix = alphaDip * (1 - mix), alpha;
|
||||
let alphaDip = from.alpha * to.interruptAlpha, alphaMix = alphaDip * (1 - mix), alpha = 0;
|
||||
from.totalAlpha = 0;
|
||||
for (var i = 0; i < timelineCount; i++) {
|
||||
let timeline = timelines[i];
|
||||
|
||||
@ -324,7 +324,7 @@ module spine {
|
||||
|
||||
let lengths: Array<number> = Utils.newArray(vertexCount / 3, 0);
|
||||
for (let i = 0; i < map.lengths.length; i++)
|
||||
lengths[i++] = map.lengths[i] * scale;
|
||||
lengths[i] = map.lengths[i] * scale;
|
||||
path.lengths = lengths;
|
||||
|
||||
let color: string = this.getValue(map, "color", null);
|
||||
|
||||
@ -192,6 +192,28 @@ namespace Spine.Unity.Editor {
|
||||
|
||||
protected override Texture2D Icon { get { return SpineEditorUtilities.Icons.skin; } }
|
||||
|
||||
public static void GetSkinMenuItems (SkeletonData data, List<string> animationNames, List<GUIContent> menuItems, bool includeNone = true) {
|
||||
if (data == null) return;
|
||||
|
||||
var skins = data.Skins;
|
||||
|
||||
animationNames.Clear();
|
||||
menuItems.Clear();
|
||||
|
||||
var icon = SpineEditorUtilities.Icons.skin;
|
||||
|
||||
if (includeNone) {
|
||||
animationNames.Add("");
|
||||
menuItems.Add(new GUIContent(NoneString, icon));
|
||||
}
|
||||
|
||||
foreach (var s in skins) {
|
||||
var skinName = s.Name;
|
||||
animationNames.Add(skinName);
|
||||
menuItems.Add(new GUIContent(skinName, icon));
|
||||
}
|
||||
}
|
||||
|
||||
protected override void PopulateMenu (GenericMenu menu, SerializedProperty property, SpineSkin targetAttribute, SkeletonData data) {
|
||||
menu.AddDisabledItem(new GUIContent(skeletonDataAsset.name));
|
||||
menu.AddSeparator("");
|
||||
@ -210,6 +232,26 @@ namespace Spine.Unity.Editor {
|
||||
|
||||
protected override Texture2D Icon { get { return SpineEditorUtilities.Icons.animation; } }
|
||||
|
||||
public static void GetAnimationMenuItems (SkeletonData data, List<string> animationNames, List<GUIContent> menuItems, bool includeNone = true) {
|
||||
if (data == null) return;
|
||||
|
||||
var animations = data.Animations;
|
||||
|
||||
animationNames.Clear();
|
||||
menuItems.Clear();
|
||||
|
||||
if (includeNone) {
|
||||
animationNames.Add("");
|
||||
menuItems.Add(new GUIContent(NoneString, SpineEditorUtilities.Icons.animation));
|
||||
}
|
||||
|
||||
foreach (var a in animations) {
|
||||
var animationName = a.Name;
|
||||
animationNames.Add(animationName);
|
||||
menuItems.Add(new GUIContent(animationName, SpineEditorUtilities.Icons.animation));
|
||||
}
|
||||
}
|
||||
|
||||
protected override void PopulateMenu (GenericMenu menu, SerializedProperty property, SpineAnimation targetAttribute, SkeletonData data) {
|
||||
var animations = skeletonDataAsset.GetAnimationStateData().SkeletonData.Animations;
|
||||
|
||||
@ -230,6 +272,26 @@ namespace Spine.Unity.Editor {
|
||||
|
||||
protected override Texture2D Icon { get { return SpineEditorUtilities.Icons.userEvent; } }
|
||||
|
||||
public static void GetEventMenuItems (SkeletonData data, List<string> eventNames, List<GUIContent> menuItems, bool includeNone = true) {
|
||||
if (data == null) return;
|
||||
|
||||
var animations = data.Events;
|
||||
|
||||
eventNames.Clear();
|
||||
menuItems.Clear();
|
||||
|
||||
if (includeNone) {
|
||||
eventNames.Add("");
|
||||
menuItems.Add(new GUIContent(NoneString, SpineEditorUtilities.Icons.userEvent));
|
||||
}
|
||||
|
||||
foreach (var a in animations) {
|
||||
var animationName = a.Name;
|
||||
eventNames.Add(animationName);
|
||||
menuItems.Add(new GUIContent(animationName, SpineEditorUtilities.Icons.userEvent));
|
||||
}
|
||||
}
|
||||
|
||||
protected override void PopulateMenu (GenericMenu menu, SerializedProperty property, SpineEvent targetAttribute, SkeletonData data) {
|
||||
var events = skeletonDataAsset.GetSkeletonData(false).Events;
|
||||
|
||||
|
||||
@ -196,7 +196,7 @@ namespace Spine.Unity.Editor {
|
||||
graphic.MeshGenerator.settings.zSpacing = SpineEditorUtilities.defaultZSpacing;
|
||||
|
||||
graphic.Initialize(false);
|
||||
graphic.Skeleton.SetSkin(skin);
|
||||
if (skin != null) graphic.Skeleton.SetSkin(skin);
|
||||
graphic.initialSkinName = skin.Name;
|
||||
graphic.Skeleton.UpdateWorldTransform();
|
||||
graphic.UpdateMesh();
|
||||
|
||||
@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: dfdd78a071ca1a04bb64c6cc41e14aa0
|
||||
folderAsset: yes
|
||||
timeCreated: 1496447038
|
||||
licenseType: Free
|
||||
DefaultImporter:
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 1ad4318c20ec5674a9f4d7f786afd681
|
||||
folderAsset: yes
|
||||
timeCreated: 1496449217
|
||||
licenseType: Free
|
||||
DefaultImporter:
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,47 @@
|
||||
/******************************************************************************
|
||||
* Spine Runtimes Software License v2.5
|
||||
*
|
||||
* Copyright (c) 2013-2016, Esoteric Software
|
||||
* All rights reserved.
|
||||
*
|
||||
* You are granted a perpetual, non-exclusive, non-sublicensable, and
|
||||
* non-transferable license to use, install, execute, and perform the Spine
|
||||
* Runtimes software and derivative works solely for personal or internal
|
||||
* use. Without the written permission of Esoteric Software (see Section 2 of
|
||||
* the Spine Software License Agreement), you may not (a) modify, translate,
|
||||
* adapt, or develop new applications using the Spine Runtimes or otherwise
|
||||
* create derivative works or improvements of the Spine Runtimes or (b) remove,
|
||||
* delete, alter, or obscure any trademarks or any copyright, trademark, patent,
|
||||
* or other intellectual property or proprietary rights notices on or in the
|
||||
* Software, including any copy thereof. Redistributions in binary or source
|
||||
* form must include this license and terms.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
||||
* EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS INTERRUPTION, OR LOSS OF
|
||||
* USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
||||
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*****************************************************************************/
|
||||
|
||||
using UnityEngine;
|
||||
using UnityEditor;
|
||||
using Spine.Unity.Modules;
|
||||
|
||||
namespace Spine.Unity.Editor {
|
||||
using Editor = UnityEditor.Editor;
|
||||
|
||||
public class SlotBlendModesEditor : Editor {
|
||||
|
||||
[MenuItem("CONTEXT/SkeletonRenderer/Add Slot Blend Modes Component")]
|
||||
static void AddSlotBlendModesComponent (MenuCommand command) {
|
||||
var skeletonRenderer = (SkeletonRenderer)command.context;
|
||||
skeletonRenderer.gameObject.AddComponent<SlotBlendModes>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,12 @@
|
||||
fileFormatVersion: 2
|
||||
guid: cbec7dc66dca80a419477536c23b7a0d
|
||||
timeCreated: 1496449255
|
||||
licenseType: Free
|
||||
MonoImporter:
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,43 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!21 &2100000
|
||||
Material:
|
||||
serializedVersion: 6
|
||||
m_ObjectHideFlags: 0
|
||||
m_PrefabParentObject: {fileID: 0}
|
||||
m_PrefabInternal: {fileID: 0}
|
||||
m_Name: SkeletonPMAMultiply
|
||||
m_Shader: {fileID: 4800000, guid: 8bdcdc7ee298e594a9c20c61d25c33b6, type: 3}
|
||||
m_ShaderKeywords:
|
||||
m_LightmapFlags: 4
|
||||
m_CustomRenderQueue: -1
|
||||
stringTagMap: {}
|
||||
m_SavedProperties:
|
||||
serializedVersion: 2
|
||||
m_TexEnvs:
|
||||
- first:
|
||||
name: <noninit>
|
||||
second:
|
||||
m_Texture: {fileID: 0}
|
||||
m_Scale: {x: 1, y: 1}
|
||||
m_Offset: {x: 0, y: 0}
|
||||
- first:
|
||||
name: _MainTex
|
||||
second:
|
||||
m_Texture: {fileID: 0}
|
||||
m_Scale: {x: 1, y: 1}
|
||||
m_Offset: {x: 0, y: 0}
|
||||
m_Floats:
|
||||
- first:
|
||||
name: <noninit>
|
||||
second: 0
|
||||
- first:
|
||||
name: _Cutoff
|
||||
second: 0.1
|
||||
m_Colors:
|
||||
- first:
|
||||
name: <noninit>
|
||||
second: {r: 0, g: 2.018574, b: 1e-45, a: 0.000007110106}
|
||||
- first:
|
||||
name: _Color
|
||||
second: {r: 1, g: 1, b: 1, a: 1}
|
||||
@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 53bf0ab317d032d418cf1252d68f51df
|
||||
timeCreated: 1496447909
|
||||
licenseType: Free
|
||||
NativeFormatImporter:
|
||||
mainObjectFileID: 2100000
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,43 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!21 &2100000
|
||||
Material:
|
||||
serializedVersion: 6
|
||||
m_ObjectHideFlags: 0
|
||||
m_PrefabParentObject: {fileID: 0}
|
||||
m_PrefabInternal: {fileID: 0}
|
||||
m_Name: SkeletonPMAScreen
|
||||
m_Shader: {fileID: 4800000, guid: 4e8caa36c07aacf4ab270da00784e4d9, type: 3}
|
||||
m_ShaderKeywords:
|
||||
m_LightmapFlags: 4
|
||||
m_CustomRenderQueue: -1
|
||||
stringTagMap: {}
|
||||
m_SavedProperties:
|
||||
serializedVersion: 2
|
||||
m_TexEnvs:
|
||||
- first:
|
||||
name: <noninit>
|
||||
second:
|
||||
m_Texture: {fileID: 0}
|
||||
m_Scale: {x: 1, y: 1}
|
||||
m_Offset: {x: 0, y: 0}
|
||||
- first:
|
||||
name: _MainTex
|
||||
second:
|
||||
m_Texture: {fileID: 0}
|
||||
m_Scale: {x: 1, y: 1}
|
||||
m_Offset: {x: 0, y: 0}
|
||||
m_Floats:
|
||||
- first:
|
||||
name: <noninit>
|
||||
second: 0
|
||||
- first:
|
||||
name: _Cutoff
|
||||
second: 0.1
|
||||
m_Colors:
|
||||
- first:
|
||||
name: <noninit>
|
||||
second: {r: 0, g: 2.018574, b: 1e-45, a: 0.000007121922}
|
||||
- first:
|
||||
name: _Color
|
||||
second: {r: 1, g: 1, b: 1, a: 1}
|
||||
@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 73f0f46d3177c614baf0fa48d646a9be
|
||||
timeCreated: 1496447909
|
||||
licenseType: Free
|
||||
NativeFormatImporter:
|
||||
mainObjectFileID: 2100000
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,152 @@
|
||||
/******************************************************************************
|
||||
* Spine Runtimes Software License v2.5
|
||||
*
|
||||
* Copyright (c) 2013-2016, Esoteric Software
|
||||
* All rights reserved.
|
||||
*
|
||||
* You are granted a perpetual, non-exclusive, non-sublicensable, and
|
||||
* non-transferable license to use, install, execute, and perform the Spine
|
||||
* Runtimes software and derivative works solely for personal or internal
|
||||
* use. Without the written permission of Esoteric Software (see Section 2 of
|
||||
* the Spine Software License Agreement), you may not (a) modify, translate,
|
||||
* adapt, or develop new applications using the Spine Runtimes or otherwise
|
||||
* create derivative works or improvements of the Spine Runtimes or (b) remove,
|
||||
* delete, alter, or obscure any trademarks or any copyright, trademark, patent,
|
||||
* or other intellectual property or proprietary rights notices on or in the
|
||||
* Software, including any copy thereof. Redistributions in binary or source
|
||||
* form must include this license and terms.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
||||
* EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS INTERRUPTION, OR LOSS OF
|
||||
* USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
||||
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*****************************************************************************/
|
||||
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
|
||||
namespace Spine.Unity.Modules {
|
||||
|
||||
[DisallowMultipleComponent]
|
||||
public class SlotBlendModes : MonoBehaviour {
|
||||
|
||||
#region Internal Material Dictionary
|
||||
public struct MaterialTexturePair {
|
||||
public Texture2D texture2D;
|
||||
public Material material;
|
||||
}
|
||||
|
||||
static Dictionary<MaterialTexturePair, Material> materialTable;
|
||||
internal static Dictionary<MaterialTexturePair, Material> MaterialTable {
|
||||
get {
|
||||
if (materialTable == null) materialTable = new Dictionary<MaterialTexturePair, Material>();
|
||||
return materialTable;
|
||||
}
|
||||
}
|
||||
|
||||
internal static Material GetMaterialFor (Material materialSource, Texture2D texture) {
|
||||
if (materialSource == null || texture == null) return null;
|
||||
|
||||
var mt = SlotBlendModes.MaterialTable;
|
||||
Material m;
|
||||
var key = new MaterialTexturePair { material = materialSource, texture2D = texture };
|
||||
if (!mt.TryGetValue(key, out m)) {
|
||||
m = new Material(materialSource);
|
||||
m.name = "(Clone)" + texture.name + "-" + materialSource.name;
|
||||
m.mainTexture = texture;
|
||||
mt[key] = m;
|
||||
}
|
||||
|
||||
return m;
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Inspector
|
||||
public Material multiplyMaterialSource;
|
||||
public Material screenMaterialSource;
|
||||
|
||||
Texture2D texture;
|
||||
#endregion
|
||||
|
||||
public bool Applied { get; private set; }
|
||||
|
||||
void Start () {
|
||||
if (!Applied) Apply();
|
||||
}
|
||||
|
||||
void OnDestroy () {
|
||||
if (Applied) Remove();
|
||||
}
|
||||
|
||||
public void Apply () {
|
||||
GetTexture();
|
||||
if (texture == null) return;
|
||||
|
||||
var skeletonRenderer = GetComponent<SkeletonRenderer>();
|
||||
if (skeletonRenderer == null) return;
|
||||
|
||||
var slotMaterials = skeletonRenderer.CustomSlotMaterials;
|
||||
|
||||
foreach (var s in skeletonRenderer.Skeleton.Slots) {
|
||||
switch (s.data.blendMode) {
|
||||
case BlendMode.Multiply:
|
||||
if (multiplyMaterialSource != null) slotMaterials[s] = GetMaterialFor(multiplyMaterialSource, texture);
|
||||
break;
|
||||
case BlendMode.Screen:
|
||||
if (screenMaterialSource != null) slotMaterials[s] = GetMaterialFor(screenMaterialSource, texture);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Applied = true;
|
||||
skeletonRenderer.LateUpdate();
|
||||
}
|
||||
|
||||
public void Remove () {
|
||||
GetTexture();
|
||||
if (texture == null) return;
|
||||
|
||||
var skeletonRenderer = GetComponent<SkeletonRenderer>();
|
||||
if (skeletonRenderer == null) return;
|
||||
|
||||
var slotMaterials = skeletonRenderer.CustomSlotMaterials;
|
||||
|
||||
foreach (var s in skeletonRenderer.Skeleton.Slots) {
|
||||
Material m = null;
|
||||
|
||||
switch (s.data.blendMode) {
|
||||
case BlendMode.Multiply:
|
||||
if (slotMaterials.TryGetValue(s, out m) && Material.ReferenceEquals(m, GetMaterialFor(multiplyMaterialSource, texture)))
|
||||
slotMaterials.Remove(s);
|
||||
break;
|
||||
case BlendMode.Screen:
|
||||
if (slotMaterials.TryGetValue(s, out m) && Material.ReferenceEquals(m, GetMaterialFor(screenMaterialSource, texture)))
|
||||
slotMaterials.Remove(s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Applied = false;
|
||||
skeletonRenderer.LateUpdate();
|
||||
}
|
||||
|
||||
public void GetTexture () {
|
||||
if (texture == null) {
|
||||
var sr = GetComponent<SkeletonRenderer>(); if (sr == null) return;
|
||||
var sda = sr.skeletonDataAsset; if (sda == null) return;
|
||||
var aa = sda.atlasAssets[0]; if (aa == null) return;
|
||||
var am = aa.materials[0]; if (am == null) return;
|
||||
texture = am.mainTexture as Texture2D;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: f1f8243645ba2e74aa3564bd956eed89
|
||||
timeCreated: 1496794038
|
||||
licenseType: Free
|
||||
MonoImporter:
|
||||
serializedVersion: 2
|
||||
defaultReferences:
|
||||
- multiplyMaterialSource: {fileID: 2100000, guid: 53bf0ab317d032d418cf1252d68f51df,
|
||||
type: 2}
|
||||
- screenMaterialSource: {fileID: 2100000, guid: 73f0f46d3177c614baf0fa48d646a9be,
|
||||
type: 2}
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,101 @@
|
||||
// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
|
||||
|
||||
// Spine/Skeleton PMA Multiply
|
||||
// - single color multiply tint
|
||||
// - unlit
|
||||
// - Premultiplied alpha Multiply blending
|
||||
// - No depth, no backface culling, no fog.
|
||||
// - ShadowCaster pass
|
||||
|
||||
Shader "Spine/Skeleton PMA Multiply" {
|
||||
Properties {
|
||||
_Color ("Tint Color", Color) = (1,1,1,1)
|
||||
[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
|
||||
_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
|
||||
}
|
||||
|
||||
SubShader {
|
||||
Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
|
||||
LOD 100
|
||||
|
||||
Fog { Mode Off }
|
||||
Cull Off
|
||||
ZWrite Off
|
||||
Blend DstColor OneMinusSrcAlpha
|
||||
Lighting Off
|
||||
|
||||
Pass {
|
||||
CGPROGRAM
|
||||
#pragma vertex vert
|
||||
#pragma fragment frag
|
||||
#include "UnityCG.cginc"
|
||||
uniform sampler2D _MainTex;
|
||||
uniform float4 _Color;
|
||||
|
||||
struct VertexInput {
|
||||
float4 vertex : POSITION;
|
||||
float2 uv : TEXCOORD0;
|
||||
float4 vertexColor : COLOR;
|
||||
};
|
||||
|
||||
struct VertexOutput {
|
||||
float4 pos : SV_POSITION;
|
||||
float2 uv : TEXCOORD0;
|
||||
float4 vertexColor : COLOR;
|
||||
};
|
||||
|
||||
VertexOutput vert (VertexInput v) {
|
||||
VertexOutput o;
|
||||
o.pos = UnityObjectToClipPos(v.vertex);
|
||||
o.uv = v.uv;
|
||||
o.vertexColor = v.vertexColor * float4(_Color.rgb * _Color.a, _Color.a); // Combine a PMA version of _Color with vertexColor.
|
||||
return o;
|
||||
}
|
||||
|
||||
float4 frag (VertexOutput i) : COLOR {
|
||||
float4 texColor = tex2D(_MainTex, i.uv);
|
||||
return (texColor * i.vertexColor);
|
||||
}
|
||||
ENDCG
|
||||
}
|
||||
|
||||
Pass {
|
||||
Name "Caster"
|
||||
Tags { "LightMode"="ShadowCaster" }
|
||||
Offset 1, 1
|
||||
|
||||
ZWrite On
|
||||
ZTest LEqual
|
||||
|
||||
CGPROGRAM
|
||||
#pragma vertex vert
|
||||
#pragma fragment frag
|
||||
#pragma multi_compile_shadowcaster
|
||||
#pragma fragmentoption ARB_precision_hint_fastest
|
||||
#include "UnityCG.cginc"
|
||||
struct v2f {
|
||||
V2F_SHADOW_CASTER;
|
||||
float2 uv : TEXCOORD1;
|
||||
};
|
||||
|
||||
uniform float4 _MainTex_ST;
|
||||
|
||||
v2f vert (appdata_base v) {
|
||||
v2f o;
|
||||
TRANSFER_SHADOW_CASTER(o)
|
||||
o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
|
||||
return o;
|
||||
}
|
||||
|
||||
uniform sampler2D _MainTex;
|
||||
uniform fixed _Cutoff;
|
||||
|
||||
float4 frag (v2f i) : COLOR {
|
||||
fixed4 texcol = tex2D(_MainTex, i.uv);
|
||||
clip(texcol.a - _Cutoff);
|
||||
SHADOW_CASTER_FRAGMENT(i)
|
||||
}
|
||||
ENDCG
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 8bdcdc7ee298e594a9c20c61d25c33b6
|
||||
timeCreated: 1496446742
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,99 @@
|
||||
// Spine/Skeleton PMA Multiply
|
||||
// - single color multiply tint
|
||||
// - unlit
|
||||
// - Premultiplied alpha Multiply blending
|
||||
// - No depth, no backface culling, no fog.
|
||||
// - ShadowCaster pass
|
||||
|
||||
Shader "Spine/Skeleton PMA Screen" {
|
||||
Properties {
|
||||
_Color ("Tint Color", Color) = (1,1,1,1)
|
||||
[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
|
||||
_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
|
||||
}
|
||||
|
||||
SubShader {
|
||||
Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
|
||||
LOD 100
|
||||
|
||||
Fog { Mode Off }
|
||||
Cull Off
|
||||
ZWrite Off
|
||||
Blend One OneMinusSrcColor
|
||||
Lighting Off
|
||||
|
||||
Pass {
|
||||
CGPROGRAM
|
||||
#pragma vertex vert
|
||||
#pragma fragment frag
|
||||
#include "UnityCG.cginc"
|
||||
uniform sampler2D _MainTex;
|
||||
uniform float4 _Color;
|
||||
|
||||
struct VertexInput {
|
||||
float4 vertex : POSITION;
|
||||
float2 uv : TEXCOORD0;
|
||||
float4 vertexColor : COLOR;
|
||||
};
|
||||
|
||||
struct VertexOutput {
|
||||
float4 pos : SV_POSITION;
|
||||
float2 uv : TEXCOORD0;
|
||||
float4 vertexColor : COLOR;
|
||||
};
|
||||
|
||||
VertexOutput vert (VertexInput v) {
|
||||
VertexOutput o;
|
||||
o.pos = UnityObjectToClipPos(v.vertex);
|
||||
o.uv = v.uv;
|
||||
o.vertexColor = v.vertexColor * float4(_Color.rgb * _Color.a, _Color.a); // Combine a PMA version of _Color with vertexColor.
|
||||
return o;
|
||||
}
|
||||
|
||||
float4 frag (VertexOutput i) : COLOR {
|
||||
float4 texColor = tex2D(_MainTex, i.uv);
|
||||
return (texColor * i.vertexColor);
|
||||
}
|
||||
ENDCG
|
||||
}
|
||||
|
||||
Pass {
|
||||
Name "Caster"
|
||||
Tags { "LightMode"="ShadowCaster" }
|
||||
Offset 1, 1
|
||||
|
||||
ZWrite On
|
||||
ZTest LEqual
|
||||
|
||||
CGPROGRAM
|
||||
#pragma vertex vert
|
||||
#pragma fragment frag
|
||||
#pragma multi_compile_shadowcaster
|
||||
#pragma fragmentoption ARB_precision_hint_fastest
|
||||
#include "UnityCG.cginc"
|
||||
struct v2f {
|
||||
V2F_SHADOW_CASTER;
|
||||
float2 uv : TEXCOORD1;
|
||||
};
|
||||
|
||||
uniform float4 _MainTex_ST;
|
||||
|
||||
v2f vert (appdata_base v) {
|
||||
v2f o;
|
||||
TRANSFER_SHADOW_CASTER(o)
|
||||
o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
|
||||
return o;
|
||||
}
|
||||
|
||||
uniform sampler2D _MainTex;
|
||||
uniform fixed _Cutoff;
|
||||
|
||||
float4 frag (v2f i) : COLOR {
|
||||
fixed4 texcol = tex2D(_MainTex, i.uv);
|
||||
clip(texcol.a - _Cutoff);
|
||||
SHADOW_CASTER_FRAGMENT(i)
|
||||
}
|
||||
ENDCG
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 4e8caa36c07aacf4ab270da00784e4d9
|
||||
timeCreated: 1496448787
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
Loading…
x
Reference in New Issue
Block a user