UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-03-25 22:23:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Prefixed all spine-c structs and functions with "sp".

Browse Source 
Holy refuctoring! Sorry for the change, but some libraries were having naming conflicts. You can define SPINE_SHORT_NAMES before including spine-c headers if you want to use structs and functions without the "sp" prefix, as it was before.
This commit is contained in:
NathanSweet 2013-10-09 03:43:16 +02:00
parent 819b100a51
commit 2bff08de4b
56 changed files with 1281 additions and 979 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
spine-c/example/main.c
View File

@ -9,47 +9,47 @@
/**/
void _AtlasPage_createTexture (AtlasPage* self, const char* path) {
void _spAtlasPage_createTexture (spAtlasPage* self, const char* path) {
self->rendererObject = 0;
self->width = 123;
self->height = 456;
}
void _AtlasPage_disposeTexture (AtlasPage* self) {
void _spAtlasPage_disposeTexture (spAtlasPage* self) {
}
char* _Util_readFile (const char* path, int* length) {
char* _spUtil_readFile (const char* path, int* length) {
return _readFile(path, length);
}
/**/
int main (void) {
Atlas* atlas = Atlas_readAtlasFile("data/spineboy.atlas");
spAtlas* atlas = spAtlas_readAtlasFile("data/spineboy.atlas");
printf("First region name: %s, x: %d, y: %d\n", atlas->regions->name, atlas->regions->x, atlas->regions->y);
printf("First page name: %s, size: %d, %d\n", atlas->pages->name, atlas->pages->width, atlas->pages->height);
SkeletonJson* json = SkeletonJson_create(atlas);
SkeletonData *skeletonData = SkeletonJson_readSkeletonDataFile(json, "data/spineboy.json");
spSkeletonJson* json = spSkeletonJson_create(atlas);
spSkeletonData *skeletonData = spSkeletonJson_readSkeletonDataFile(json, "data/spineboy.json");
if (!skeletonData) {
printf("Error: %s\n", json->error);
exit(0);
}
printf("Default skin name: %s\n", skeletonData->defaultSkin->name);
Skeleton* skeleton = Skeleton_create(skeletonData);
spSkeleton* skeleton = spSkeleton_create(skeletonData);
Animation* animation = SkeletonData_findAnimation(skeletonData, "walk");
spAnimation* animation = spSkeletonData_findAnimation(skeletonData, "walk");
if (!animation) {
printf("Error: Animation not found: walk\n");
exit(0);
}
printf("Animation timelineCount: %d\n", animation->timelineCount);
Skeleton_dispose(skeleton);
SkeletonData_dispose(skeletonData);
SkeletonJson_dispose(json);
Atlas_dispose(atlas);
spSkeleton_dispose(skeleton);
spSkeletonData_dispose(skeletonData);
spSkeletonJson_dispose(json);
spAtlas_dispose(atlas);
return 0;
}
}

156
spine-c/include/spine/Animation.h
View File

@ -40,142 +40,206 @@
extern "C" {
#endif
typedef struct Timeline Timeline;
struct Skeleton;
typedef struct spTimeline spTimeline;
struct spSkeleton;
typedef struct {
const char* const name;
float duration;
int timelineCount;
Timeline** timelines;
} Animation;
spTimeline** timelines;
} spAnimation;
Animation* Animation_create (const char* name, int timelineCount);
void Animation_dispose (Animation* self);
spAnimation* spAnimation_create (const char* name, int timelineCount);
void spAnimation_dispose (spAnimation* self);
/** Poses the skeleton at the specified time for this animation.
* @param lastTime The last time the animation was applied.
* @param events Any triggered events are added. */
void Animation_apply (const Animation* self, struct Skeleton* skeleton, float lastTime, float time, int loop,
Event** events, int* eventCount);
void spAnimation_apply (const spAnimation* self, struct spSkeleton* skeleton, float lastTime, float time, int loop,
spEvent** events, int* eventCount);
/** Poses the skeleton at the specified time for this animation mixed with the current pose.
* @param lastTime The last time the animation was applied.
* @param events Any triggered events are added.
* @param alpha The amount of this animation that affects the current pose. */
void Animation_mix (const Animation* self, struct Skeleton* skeleton, float lastTime, float time, int loop, Event** events,
void spAnimation_mix (const spAnimation* self, struct spSkeleton* skeleton, float lastTime, float time, int loop, spEvent** events,
int* eventCount, float alpha);
#ifdef SPINE_SHORT_NAMES
typedef spAnimation Animation;
#define Animation_create(...) spAnimation_create(__VA_ARGS__)
#define Animation_dispose(...) spAnimation_dispose(__VA_ARGS__)
#define Animation_apply(...) spAnimation_apply(__VA_ARGS__)
#define Animation_mix(...) spAnimation_mix(__VA_ARGS__)
#endif
/**/
struct Timeline {
struct spTimeline {
const void* const vtable;
};
void Timeline_dispose (Timeline* self);
void Timeline_apply (const Timeline* self, struct Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void spTimeline_dispose (spTimeline* self);
void spTimeline_apply (const spTimeline* self, struct spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha);
#ifdef SPINE_SHORT_NAMES
typedef spTimeline Timeline;
#define Timeline_dispose(...) spTimeline_dispose(__VA_ARGS__)
#define Timeline_apply(...) spTimeline_apply(__VA_ARGS__)
#endif
/**/
typedef struct {
Timeline super;
spTimeline super;
float* curves; /* dfx, dfy, ddfx, ddfy, dddfx, dddfy, ... */
} CurveTimeline;
} spCurveTimeline;
void CurveTimeline_setLinear (CurveTimeline* self, int frameIndex);
void CurveTimeline_setStepped (CurveTimeline* self, int frameIndex);
void spCurveTimeline_setLinear (spCurveTimeline* self, int frameIndex);
void spCurveTimeline_setStepped (spCurveTimeline* self, int frameIndex);
/* Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next.
* cx1 and cx2 are from 0 to 1, representing the percent of time between the two keyframes. cy1 and cy2 are the percent of
* the difference between the keyframe's values. */
void CurveTimeline_setCurve (CurveTimeline* self, int frameIndex, float cx1, float cy1, float cx2, float cy2);
float CurveTimeline_getCurvePercent (const CurveTimeline* self, int frameIndex, float percent);
void spCurveTimeline_setCurve (spCurveTimeline* self, int frameIndex, float cx1, float cy1, float cx2, float cy2);
float spCurveTimeline_getCurvePercent (const spCurveTimeline* self, int frameIndex, float percent);
#ifdef SPINE_SHORT_NAMES
typedef spCurveTimeline CurveTimeline;
#define CurveTimeline_setLinear(...) spCurveTimeline_setLinear(__VA_ARGS__)
#define CurveTimeline_setStepped(...) spCurveTimeline_setStepped(__VA_ARGS__)
#define CurveTimeline_setCurve(...) spCurveTimeline_setCurve(__VA_ARGS__)
#define CurveTimeline_getCurvePercent(...) spCurveTimeline_getCurvePercent(__VA_ARGS__)
#endif
/**/
typedef struct BaseTimeline {
CurveTimeline super;
typedef struct spBaseTimeline {
spCurveTimeline super;
int const framesLength;
float* const frames; /* time, angle, ... for rotate. time, x, y, ... for translate and scale. */
int boneIndex;
} RotateTimeline;
} spRotateTimeline;
RotateTimeline* RotateTimeline_create (int frameCount);
spRotateTimeline* spRotateTimeline_create (int frameCount);
void RotateTimeline_setFrame (RotateTimeline* self, int frameIndex, float time, float angle);
void spRotateTimeline_setFrame (spRotateTimeline* self, int frameIndex, float time, float angle);
#ifdef SPINE_SHORT_NAMES
typedef spRotateTimeline RotateTimeline;
#define RotateTimeline_create(...) spRotateTimeline_create(__VA_ARGS__)
#define RotateTimeline_setFrame(...) spRotateTimeline_setFrame(__VA_ARGS__)
#endif
/**/
typedef struct BaseTimeline TranslateTimeline;
typedef struct spBaseTimeline spTranslateTimeline;
TranslateTimeline* TranslateTimeline_create (int frameCount);
spTranslateTimeline* spTranslateTimeline_create (int frameCount);
void TranslateTimeline_setFrame (TranslateTimeline* self, int frameIndex, float time, float x, float y);
void spTranslateTimeline_setFrame (spTranslateTimeline* self, int frameIndex, float time, float x, float y);
#ifdef SPINE_SHORT_NAMES
typedef spTranslateTimeline TranslateTimeline;
#define TranslateTimeline_create(...) spTranslateTimeline_create(__VA_ARGS__)
#define TranslateTimeline_setFrame(...) spTranslateTimeline_setFrame(__VA_ARGS__)
#endif
/**/
typedef struct BaseTimeline ScaleTimeline;
typedef struct spBaseTimeline spScaleTimeline;
ScaleTimeline* ScaleTimeline_create (int frameCount);
spScaleTimeline* spScaleTimeline_create (int frameCount);
void ScaleTimeline_setFrame (ScaleTimeline* self, int frameIndex, float time, float x, float y);
void spScaleTimeline_setFrame (spScaleTimeline* self, int frameIndex, float time, float x, float y);
#ifdef SPINE_SHORT_NAMES
typedef spScaleTimeline ScaleTimeline;
#define ScaleTimeline_create(...) spScaleTimeline_create(__VA_ARGS__)
#define ScaleTimeline_setFrame(...) spScaleTimeline_setFrame(__VA_ARGS__)
#endif
/**/
typedef struct {
CurveTimeline super;
spCurveTimeline super;
int const framesLength;
float* const frames; /* time, r, g, b, a, ... */
int slotIndex;
} ColorTimeline;
} spColorTimeline;
ColorTimeline* ColorTimeline_create (int frameCount);
spColorTimeline* spColorTimeline_create (int frameCount);
void ColorTimeline_setFrame (ColorTimeline* self, int frameIndex, float time, float r, float g, float b, float a);
void spColorTimeline_setFrame (spColorTimeline* self, int frameIndex, float time, float r, float g, float b, float a);
#ifdef SPINE_SHORT_NAMES
typedef spColorTimeline ColorTimeline;
#define ColorTimeline_create(...) spColorTimeline_create(__VA_ARGS__)
#define ColorTimeline_setFrame(...) spColorTimeline_setFrame(__VA_ARGS__)
#endif
/**/
typedef struct {
Timeline super;
spTimeline super;
int const framesLength;
float* const frames; /* time, ... */
int slotIndex;
const char** const attachmentNames;
} AttachmentTimeline;
} spAttachmentTimeline;
AttachmentTimeline* AttachmentTimeline_create (int frameCount);
spAttachmentTimeline* spAttachmentTimeline_create (int frameCount);
/* @param attachmentName May be 0. */
void AttachmentTimeline_setFrame (AttachmentTimeline* self, int frameIndex, float time, const char* attachmentName);
void spAttachmentTimeline_setFrame (spAttachmentTimeline* self, int frameIndex, float time, const char* attachmentName);
#ifdef SPINE_SHORT_NAMES
typedef spAttachmentTimeline AttachmentTimeline;
#define AttachmentTimeline_create(...) spAttachmentTimeline_create(__VA_ARGS__)
#define AttachmentTimeline_setFrame(...) spAttachmentTimeline_setFrame(__VA_ARGS__)
#endif
/**/
typedef struct {
Timeline super;
spTimeline super;
int const framesLength;
float* const frames; /* time, ... */
Event** const events;
} EventTimeline;
spEvent** const events;
} spEventTimeline;
EventTimeline* EventTimeline_create (int frameCount);
spEventTimeline* spEventTimeline_create (int frameCount);
void EventTimeline_setFrame (EventTimeline* self, int frameIndex, float time, Event* event);
void spEventTimeline_setFrame (spEventTimeline* self, int frameIndex, float time, spEvent* event);
#ifdef SPINE_SHORT_NAMES
typedef spEventTimeline EventTimeline;
#define EventTimeline_create(...) spEventTimeline_create(__VA_ARGS__)
#define EventTimeline_setFrame(...) spEventTimeline_setFrame(__VA_ARGS__)
#endif
/**/
typedef struct {
Timeline super;
spTimeline super;
int const framesLength;
float* const frames; /* time, ... */
const int** const drawOrders;
int const slotCount;
} DrawOrderTimeline;
} spDrawOrderTimeline;
DrawOrderTimeline* DrawOrderTimeline_create (int frameCount, int slotCount);
spDrawOrderTimeline* spDrawOrderTimeline_create (int frameCount, int slotCount);
void DrawOrderTimeline_setFrame (DrawOrderTimeline* self, int frameIndex, float time, const int* drawOrder);
void spDrawOrderTimeline_setFrame (spDrawOrderTimeline* self, int frameIndex, float time, const int* drawOrder);
#ifdef SPINE_SHORT_NAMES
typedef spDrawOrderTimeline DrawOrderTimeline;
#define DrawOrderTimeline_create(...) spDrawOrderTimeline_create(__VA_ARGS__)
#define DrawOrderTimeline_setFrame(...) spDrawOrderTimeline_setFrame(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

71
spine-c/include/spine/AnimationState.h
View File

@ -34,6 +34,7 @@
#ifndef SPINE_ANIMATIONSTATE_H_
#define SPINE_ANIMATIONSTATE_H_
#include <spine/Animation.h>
#include <spine/AnimationStateData.h>
#include <spine/Event.h>
@ -43,55 +44,75 @@ extern "C" {
typedef enum {
ANIMATION_START, ANIMATION_END, ANIMATION_COMPLETE, ANIMATION_EVENT
} EventType;
} spEventType;
typedef struct AnimationState AnimationState;
typedef struct spAnimationState spAnimationState;
typedef void (*AnimationStateListener) (AnimationState* state, int trackIndex, EventType type, Event* event, int loopCount);
typedef void (*spAnimationStateListener) (spAnimationState* state, int trackIndex, spEventType type, spEvent* event,
int loopCount);
typedef struct TrackEntry TrackEntry;
struct TrackEntry {
TrackEntry* next;
TrackEntry* previous;
Animation* animation;
typedef struct spTrackEntry spTrackEntry;
struct spTrackEntry {
spTrackEntry* next;
spTrackEntry* previous;
spAnimation* animation;
int/*bool*/loop;
float delay, time, lastTime, endTime, timeScale;
AnimationStateListener listener;
spAnimationStateListener listener;
float mixTime, mixDuration;
};
struct AnimationState {
AnimationStateData* const data;
struct spAnimationState {
spAnimationStateData* const data;
float timeScale;
AnimationStateListener listener;
spAnimationStateListener listener;
void* context;
int trackCount;
TrackEntry** tracks;
spTrackEntry** tracks;
};
/* @param data May be 0 for no mixing. */
AnimationState* AnimationState_create (AnimationStateData* data);
void AnimationState_dispose (AnimationState* self);
spAnimationState* spAnimationState_create (spAnimationStateData* data);
void spAnimationState_dispose (spAnimationState* self);
void AnimationState_update (AnimationState* self, float delta);
void AnimationState_apply (AnimationState* self, struct Skeleton* skeleton);
void spAnimationState_update (spAnimationState* self, float delta);
void spAnimationState_apply (spAnimationState* self, struct spSkeleton* skeleton);
void AnimationState_clearTracks (AnimationState* self);
void AnimationState_clearTrack (AnimationState* self, int trackIndex);
void spAnimationState_clearTracks (spAnimationState* self);
void spAnimationState_clearTrack (spAnimationState* self, int trackIndex);
/** Set the current animation. Any queued animations are cleared. */
TrackEntry* AnimationState_setAnimationByName (AnimationState* self, int trackIndex, const char* animationName, int/*bool*/loop);
TrackEntry* AnimationState_setAnimation (AnimationState* self, int trackIndex, Animation* animation, int/*bool*/loop);
spTrackEntry* spAnimationState_setAnimationByName (spAnimationState* self, int trackIndex, const char* animationName,
int/*bool*/loop);
spTrackEntry* spAnimationState_setAnimation (spAnimationState* self, int trackIndex, spAnimation* animation, int/*bool*/loop);
/** Adds an animation to be played delay seconds after the current or last queued animation, taking into account any mix
* duration. */
TrackEntry* AnimationState_addAnimationByName (AnimationState* self, int trackIndex, const char* animationName, int/*bool*/loop,
float delay);
TrackEntry* AnimationState_addAnimation (AnimationState* self, int trackIndex, Animation* animation, int/*bool*/loop,
spTrackEntry* spAnimationState_addAnimationByName (spAnimationState* self, int trackIndex, const char* animationName,
int/*bool*/loop, float delay);
spTrackEntry* spAnimationState_addAnimation (spAnimationState* self, int trackIndex, spAnimation* animation, int/*bool*/loop,
float delay);
TrackEntry* AnimationState_getCurrent (AnimationState* self, int trackIndex);
spTrackEntry* spAnimationState_getCurrent (spAnimationState* self, int trackIndex);
#ifdef SPINE_SHORT_NAMES
typedef spEventType EventType;
typedef spAnimationStateListener AnimationStateListener;
typedef spTrackEntry TrackEntry;
typedef spAnimationState AnimationState;
#define AnimationState_create(...) spAnimationState_create(__VA_ARGS__)
#define AnimationState_dispose(...) spAnimationState_dispose(__VA_ARGS__)
#define AnimationState_update(...) spAnimationState_update(__VA_ARGS__)
#define AnimationState_apply(...) spAnimationState_apply(__VA_ARGS__)
#define AnimationState_clearTracks(...) spAnimationState_clearTracks(__VA_ARGS__)
#define AnimationState_clearTrack(...) spAnimationState_clearTrack(__VA_ARGS__)
#define AnimationState_setAnimationByName(...) spAnimationState_setAnimationByName(__VA_ARGS__)
#define AnimationState_setAnimation(...) spAnimationState_setAnimation(__VA_ARGS__)
#define AnimationState_addAnimationByName(...) spAnimationState_addAnimationByName(__VA_ARGS__)
#define AnimationState_addAnimation(...) spAnimationState_addAnimation(__VA_ARGS__)
#define AnimationState_getCurrent(...) spAnimationState_getCurrent(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

23
spine-c/include/spine/AnimationStateData.h
View File

@ -42,18 +42,27 @@ extern "C" {
#endif
typedef struct {
SkeletonData* const skeletonData;
spSkeletonData* const skeletonData;
float defaultMix;
const void* const entries;
} AnimationStateData;
} spAnimationStateData;
AnimationStateData* AnimationStateData_create (SkeletonData* skeletonData);
void AnimationStateData_dispose (AnimationStateData* self);
spAnimationStateData* spAnimationStateData_create (spSkeletonData* skeletonData);
void spAnimationStateData_dispose (spAnimationStateData* self);
void AnimationStateData_setMixByName (AnimationStateData* self, const char* fromName, const char* toName, float duration);
void AnimationStateData_setMix (AnimationStateData* self, Animation* from, Animation* to, float duration);
void spAnimationStateData_setMixByName (spAnimationStateData* self, const char* fromName, const char* toName, float duration);
void spAnimationStateData_setMix (spAnimationStateData* self, spAnimation* from, spAnimation* to, float duration);
/* Returns 0 if there is no mixing between the animations. */
float AnimationStateData_getMix (AnimationStateData* self, Animation* from, Animation* to);
float spAnimationStateData_getMix (spAnimationStateData* self, spAnimation* from, spAnimation* to);
#ifdef SPINE_SHORT_NAMES
typedef spAnimationStateData AnimationStateData;
#define AnimationStateData_create(...) spAnimationStateData_create(__VA_ARGS__)
#define AnimationStateData_dispose(...) spAnimationStateData_dispose(__VA_ARGS__)
#define AnimationStateData_setMixByName(...) spAnimationStateData_setMixByName(__VA_ARGS__)
#define AnimationStateData_setMix(...) spAnimationStateData_setMix(__VA_ARGS__)
#define AnimationStateData_getMix(...) spAnimationStateData_getMix(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

71
spine-c/include/spine/Atlas.h
View File

@ -40,7 +40,7 @@ extern "C" {
typedef enum {
ATLAS_ALPHA, ATLAS_INTENSITY, ATLAS_LUMINANCE_ALPHA, ATLAS_RGB565, ATLAS_RGBA4444, ATLAS_RGB888, ATLAS_RGBA8888
} AtlasFormat;
} spAtlasFormat;
typedef enum {
ATLAS_NEAREST,
@ -50,32 +50,41 @@ typedef enum {
ATLAS_MIPMAP_LINEAR_NEAREST,
ATLAS_MIPMAP_NEAREST_LINEAR,
ATLAS_MIPMAP_LINEAR_LINEAR
} AtlasFilter;
} spAtlasFilter;
typedef enum {
ATLAS_MIRROREDREPEAT, ATLAS_CLAMPTOEDGE, ATLAS_REPEAT
} AtlasWrap;
} spAtlasWrap;
typedef struct AtlasPage AtlasPage;
struct AtlasPage {
typedef struct spAtlasPage spAtlasPage;
struct spAtlasPage {
const char* name;
AtlasFormat format;
AtlasFilter minFilter, magFilter;
AtlasWrap uWrap, vWrap;
spAtlasFormat format;
spAtlasFilter minFilter, magFilter;
spAtlasWrap uWrap, vWrap;
void* rendererObject;
int width, height;
AtlasPage* next;
spAtlasPage* next;
};
AtlasPage* AtlasPage_create (const char* name);
void AtlasPage_dispose (AtlasPage* self);
spAtlasPage* spAtlasPage_create (const char* name);
void spAtlasPage_dispose (spAtlasPage* self);
#ifdef SPINE_SHORT_NAMES
typedef spAtlasFormat AtlasFormat;
typedef spAtlasFilter AtlasFilter;
typedef spAtlasWrap AtlasWrap;
typedef spAtlasPage AtlasPage;
#define AtlasPage_create(...) spAtlasPage_create(__VA_ARGS__)
#define AtlasPage_dispose(...) spAtlasPage_dispose(__VA_ARGS__)
#endif
/**/
typedef struct AtlasRegion AtlasRegion;
struct AtlasRegion {
typedef struct spAtlasRegion spAtlasRegion;
struct spAtlasRegion {
const char* name;
int x, y, width, height;
float u, v, u2, v2;
@ -87,29 +96,43 @@ struct AtlasRegion {
int* splits;
int* pads;
AtlasPage* page;
spAtlasPage* page;
AtlasRegion* next;
spAtlasRegion* next;
};
AtlasRegion* AtlasRegion_create ();
void AtlasRegion_dispose (AtlasRegion* self);
spAtlasRegion* spAtlasRegion_create ();
void spAtlasRegion_dispose (spAtlasRegion* self);
#ifdef SPINE_SHORT_NAMES
typedef spAtlasRegion AtlasRegion;
#define AtlasRegion_create(...) spAtlasRegion_create(__VA_ARGS__)
#define AtlasRegion_dispose(...) spAtlasRegion_dispose(__VA_ARGS__)
#endif
/**/
typedef struct {
AtlasPage* pages;
AtlasRegion* regions;
} Atlas;
spAtlasPage* pages;
spAtlasRegion* regions;
} spAtlas;
/* Image files referenced in the atlas file will be prefixed with dir. */
Atlas* Atlas_readAtlas (const char* data, int length, const char* dir);
spAtlas* spAtlas_readAtlas (const char* data, int length, const char* dir);
/* Image files referenced in the atlas file will be prefixed with the directory containing the atlas file. */
Atlas* Atlas_readAtlasFile (const char* path);
void Atlas_dispose (Atlas* atlas);
spAtlas* spAtlas_readAtlasFile (const char* path);
void spAtlas_dispose (spAtlas* atlas);
/* Returns 0 if the region was not found. */
AtlasRegion* Atlas_findRegion (const Atlas* self, const char* name);
spAtlasRegion* spAtlas_findRegion (const spAtlas* self, const char* name);
#ifdef SPINE_SHORT_NAMES
typedef spAtlas Atlas;
#define Atlas_readAtlas(...) spAtlas_readAtlas(__VA_ARGS__)
#define Atlas_readAtlasFile(...) spAtlas_readAtlasFile(__VA_ARGS__)
#define Atlas_dispose(...) spAtlas_dispose(__VA_ARGS__)
#define Atlas_findRegion(...) spAtlas_findRegion(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

13
spine-c/include/spine/AtlasAttachmentLoader.h
View File

@ -42,11 +42,16 @@ extern "C" {
#endif
typedef struct {
AttachmentLoader super;
Atlas* atlas;
} AtlasAttachmentLoader;
spAttachmentLoader super;
spAtlas* atlas;
} spAtlasAttachmentLoader;
AtlasAttachmentLoader* AtlasAttachmentLoader_create (Atlas* atlas);
spAtlasAttachmentLoader* spAtlasAttachmentLoader_create (spAtlas* atlas);
#ifdef SPINE_SHORT_NAMES
typedef spAtlasAttachmentLoader AtlasAttachmentLoader;
#define AtlasAttachmentLoader_create(...) spAtlasAttachmentLoader_create(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

18
spine-c/include/spine/Attachment.h
View File

@ -38,21 +38,27 @@
extern "C" {
#endif
struct Slot;
struct spSlot;
typedef enum {
ATTACHMENT_REGION, ATTACHMENT_REGION_SEQUENCE, ATTACHMENT_BOUNDING_BOX
} AttachmentType;
} spAttachmentType;
typedef struct Attachment Attachment;
struct Attachment {
typedef struct spAttachment spAttachment;
struct spAttachment {
const char* const name;
AttachmentType type;
spAttachmentType type;
const void* const vtable;
};
void Attachment_dispose (Attachment* self);
void spAttachment_dispose (spAttachment* self);
#ifdef SPINE_SHORT_NAMES
typedef spAttachmentType AttachmentType;
typedef spAttachment Attachment;
#define Attachment_dispose(...) spAttachment_dispose(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

22
spine-c/include/spine/AttachmentLoader.h
View File

@ -41,21 +41,31 @@
extern "C" {
#endif
typedef struct AttachmentLoader AttachmentLoader;
struct AttachmentLoader {
typedef struct spAttachmentLoader spAttachmentLoader;
struct spAttachmentLoader {
const char* error1;
const char* error2;
const void* const vtable;
#ifdef __cplusplus
AttachmentLoader () : error1(0), error2(0), vtable(0) {}
spAttachmentLoader () :
error1(0),
error2(0),
vtable(0) {
}
#endif
};
void AttachmentLoader_dispose (AttachmentLoader* self);
void spAttachmentLoader_dispose (spAttachmentLoader* self);
/* Returns 0 to not load an attachment. If 0 is returned and AttachmentLoader.error1 is set, an error occurred. */
Attachment* AttachmentLoader_newAttachment (AttachmentLoader* self, Skin* skin, AttachmentType type, const char* name);
/* Returns 0 to not load an attachment. If 0 is returned and spAttachmentLoader.error1 is set, an error occurred. */
spAttachment* spAttachmentLoader_newAttachment (spAttachmentLoader* self, spSkin* skin, spAttachmentType type, const char* name);
#ifdef SPINE_SHORT_NAMES
typedef spAttachmentLoader AttachmentLoader;
#define AttachmentLoader_dispose(...) spAttachmentLoader_dispose(__VA_ARGS__)
#define AttachmentLoader_newAttachment(...) spAttachmentLoader_newAttachment(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

27
spine-c/include/spine/Bone.h
View File

@ -40,10 +40,10 @@
extern "C" {
#endif
typedef struct Bone Bone;
struct Bone {
BoneData* const data;
Bone* const parent;
typedef struct spBone spBone;
struct spBone {
spBoneData* const data;
spBone* const parent;
float x, y;
float rotation;
float scaleX, scaleY;
@ -54,15 +54,24 @@ struct Bone {
float const worldScaleX, worldScaleY;
};
void Bone_setYDown (int/*bool*/yDown);
void spBone_setYDown (int/*bool*/yDown);
/* @param parent May be 0. */
Bone* Bone_create (BoneData* data, Bone* parent);
void Bone_dispose (Bone* self);
spBone* spBone_create (spBoneData* data, spBone* parent);
void spBone_dispose (spBone* self);
void Bone_setToSetupPose (Bone* self);
void spBone_setToSetupPose (spBone* self);
void Bone_updateWorldTransform (Bone* self, int/*bool*/flipX, int/*bool*/flipY);
void spBone_updateWorldTransform (spBone* self, int/*bool*/flipX, int/*bool*/flipY);
#ifdef SPINE_SHORT_NAMES
typedef spBone Bone;
#define Bone_setYDown(...) spBone_setYDown(__VA_ARGS__)
#define Bone_create(...) spBone_create(__VA_ARGS__)
#define Bone_dispose(...) spBone_dispose(__VA_ARGS__)
#define Bone_setToSetupPose(...) spBone_setToSetupPose(__VA_ARGS__)
#define Bone_updateWorldTransform(...) spBone_updateWorldTransform(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

16
spine-c/include/spine/BoneData.h
View File

@ -38,10 +38,10 @@
extern "C" {
#endif
typedef struct BoneData BoneData;
struct BoneData {
typedef struct spBoneData spBoneData;
struct spBoneData {
const char* const name;
BoneData* const parent;
spBoneData* const parent;
float length;
float x, y;
float rotation;
@ -49,8 +49,14 @@ struct BoneData {
int/*bool*/inheritScale, inheritRotation;
};
BoneData* BoneData_create (const char* name, BoneData* parent);
void BoneData_dispose (BoneData* self);
spBoneData* spBoneData_create (const char* name, spBoneData* parent);
void spBoneData_dispose (spBoneData* self);
#ifdef SPINE_SHORT_NAMES
typedef spBoneData BoneData;
#define BoneData_create(...) spBoneData_create(__VA_ARGS__)
#define BoneData_dispose(...) spBoneData_dispose(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

16
spine-c/include/spine/BoundingBoxAttachment.h
View File

@ -42,15 +42,21 @@
extern "C" {
#endif
typedef struct BoundingBoxAttachment BoundingBoxAttachment;
struct BoundingBoxAttachment {
Attachment super;
typedef struct spBoundingBoxAttachment spBoundingBoxAttachment;
struct spBoundingBoxAttachment {
spAttachment super;
int verticesCount;
float* vertices;
};
BoundingBoxAttachment* BoundingBoxAttachment_create (const char* name);
void BoundingBoxAttachment_computeWorldVertices (BoundingBoxAttachment* self, float x, float y, Bone* bone, float* vertices);
spBoundingBoxAttachment* spBoundingBoxAttachment_create (const char* name);
void spBoundingBoxAttachment_computeWorldVertices (spBoundingBoxAttachment* self, float x, float y, spBone* bone, float* vertices);
#ifdef SPINE_SHORT_NAMES
typedef spBoundingBoxAttachment BoundingBoxAttachment;
#define BoundingBoxAttachment_create(...) spBoundingBoxAttachment_create(__VA_ARGS__)
#define BoundingBoxAttachment_computeWorldVertices(...) spBoundingBoxAttachment_computeWorldVertices(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

16
spine-c/include/spine/Event.h
View File

@ -40,16 +40,22 @@
extern "C" {
#endif
typedef struct Event Event;
struct Event {
EventData* const data;
typedef struct spEvent spEvent;
struct spEvent {
spEventData* const data;
int intValue;
float floatValue;
const char* stringValue;
};
Event* Event_create (EventData* data);
void Event_dispose (Event* self);
spEvent* spEvent_create (spEventData* data);
void spEvent_dispose (spEvent* self);
#ifdef SPINE_SHORT_NAMES
typedef spEvent Event;
#define Event_create(...) spEvent_create(__VA_ARGS__)
#define Event_dispose(...) spEvent_dispose(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

14
spine-c/include/spine/EventData.h
View File

@ -38,16 +38,22 @@
extern "C" {
#endif
typedef struct EventData EventData;
struct EventData {
typedef struct spEventData spEventData;
struct spEventData {
const char* const name;
int intValue;
float floatValue;
const char* stringValue;
};
EventData* EventData_create (const char* name);
void EventData_dispose (EventData* self);
spEventData* spEventData_create (const char* name);
void spEventData_dispose (spEventData* self);
#ifdef SPINE_SHORT_NAMES
typedef spEventData EventData;
#define EventData_create(...) spEventData_create(__VA_ARGS__)
#define EventData_dispose(...) spEventData_dispose(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

25
spine-c/include/spine/RegionAttachment.h
View File

@ -44,11 +44,11 @@ extern "C" {
typedef enum {
VERTEX_X1 = 0, VERTEX_Y1, VERTEX_X2, VERTEX_Y2, VERTEX_X3, VERTEX_Y3, VERTEX_X4, VERTEX_Y4
} VertexIndex;
} spVertexIndex;
typedef struct RegionAttachment RegionAttachment;
struct RegionAttachment {
Attachment super;
typedef struct spRegionAttachment spRegionAttachment;
struct spRegionAttachment {
spAttachment super;
float x, y, scaleX, scaleY, rotation, width, height;
void* rendererObject;
@ -60,10 +60,19 @@ struct RegionAttachment {
float uvs[8];
};
RegionAttachment* RegionAttachment_create (const char* name);
void RegionAttachment_setUVs (RegionAttachment* self, float u, float v, float u2, float v2, int/*bool*/rotate);
void RegionAttachment_updateOffset (RegionAttachment* self);
void RegionAttachment_computeWorldVertices (RegionAttachment* self, float x, float y, Bone* bone, float* vertices);
spRegionAttachment* spRegionAttachment_create (const char* name);
void spRegionAttachment_setUVs (spRegionAttachment* self, float u, float v, float u2, float v2, int/*bool*/rotate);
void spRegionAttachment_updateOffset (spRegionAttachment* self);
void spRegionAttachment_computeWorldVertices (spRegionAttachment* self, float x, float y, spBone* bone, float* vertices);
#ifdef SPINE_SHORT_NAMES
typedef spVertexIndex VertexIndex;
typedef spRegionAttachment RegionAttachment;
#define RegionAttachment_create(...) spRegionAttachment_create(__VA_ARGS__)
#define RegionAttachment_setUVs(...) spRegionAttachment_setUVs(__VA_ARGS__)
#define RegionAttachment_updateOffset(...) spRegionAttachment_updateOffset(__VA_ARGS__)
#define RegionAttachment_computeWorldVertices(...) spRegionAttachment_computeWorldVertices(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

70
spine-c/include/spine/Skeleton.h
View File

@ -42,60 +42,80 @@
extern "C" {
#endif
typedef struct Skeleton Skeleton;
struct Skeleton {
SkeletonData* const data;
typedef struct spSkeleton spSkeleton;
struct spSkeleton {
spSkeletonData* const data;
int boneCount;
Bone** bones;
Bone* const root;
spBone** bones;
spBone* const root;
int slotCount;
Slot** slots;
Slot** drawOrder;
spSlot** slots;
spSlot** drawOrder;
Skin* const skin;
spSkin* const skin;
float r, g, b, a;
float time;
int/*bool*/flipX, flipY;
float x, y;
};
Skeleton* Skeleton_create (SkeletonData* data);
void Skeleton_dispose (Skeleton* self);
spSkeleton* spSkeleton_create (spSkeletonData* data);
void spSkeleton_dispose (spSkeleton* self);
void Skeleton_updateWorldTransform (const Skeleton* self);
void spSkeleton_updateWorldTransform (const spSkeleton* self);
void Skeleton_setToSetupPose (const Skeleton* self);
void Skeleton_setBonesToSetupPose (const Skeleton* self);
void Skeleton_setSlotsToSetupPose (const Skeleton* self);
void spSkeleton_setToSetupPose (const spSkeleton* self);
void spSkeleton_setBonesToSetupPose (const spSkeleton* self);
void spSkeleton_setSlotsToSetupPose (const spSkeleton* self);
/* Returns 0 if the bone was not found. */
Bone* Skeleton_findBone (const Skeleton* self, const char* boneName);
spBone* spSkeleton_findBone (const spSkeleton* self, const char* boneName);
/* Returns -1 if the bone was not found. */
int Skeleton_findBoneIndex (const Skeleton* self, const char* boneName);
int spSkeleton_findBoneIndex (const spSkeleton* self, const char* boneName);
/* Returns 0 if the slot was not found. */
Slot* Skeleton_findSlot (const Skeleton* self, const char* slotName);
spSlot* spSkeleton_findSlot (const spSkeleton* self, const char* slotName);
/* Returns -1 if the slot was not found. */
int Skeleton_findSlotIndex (const Skeleton* self, const char* slotName);
int spSkeleton_findSlotIndex (const spSkeleton* self, const char* slotName);
/* Sets the skin used to look up attachments not found in the SkeletonData defaultSkin. Attachments from the new skin are
* attached if the corresponding attachment from the old skin was attached.
* @param skin May be 0.*/
void Skeleton_setSkin (Skeleton* self, Skin* skin);
/* Returns 0 if the skin was not found. See Skeleton_setSkin.
void spSkeleton_setSkin (spSkeleton* self, spSkin* skin);
/* Returns 0 if the skin was not found. See spSkeleton_setSkin.
* @param skinName May be 0. */
int Skeleton_setSkinByName (Skeleton* self, const char* skinName);
int spSkeleton_setSkinByName (spSkeleton* self, const char* skinName);
/* Returns 0 if the slot or attachment was not found. */
Attachment* Skeleton_getAttachmentForSlotName (const Skeleton* self, const char* slotName, const char* attachmentName);
spAttachment* spSkeleton_getAttachmentForSlotName (const spSkeleton* self, const char* slotName, const char* attachmentName);
/* Returns 0 if the slot or attachment was not found. */
Attachment* Skeleton_getAttachmentForSlotIndex (const Skeleton* self, int slotIndex, const char* attachmentName);
spAttachment* spSkeleton_getAttachmentForSlotIndex (const spSkeleton* self, int slotIndex, const char* attachmentName);
/* Returns 0 if the slot or attachment was not found. */
int Skeleton_setAttachment (Skeleton* self, const char* slotName, const char* attachmentName);
int spSkeleton_setAttachment (spSkeleton* self, const char* slotName, const char* attachmentName);
void Skeleton_update (Skeleton* self, float deltaTime);
void spSkeleton_update (spSkeleton* self, float deltaTime);
#ifdef SPINE_SHORT_NAMES
typedef spSkeleton Skeleton;
#define Skeleton_create(...) spSkeleton_create(__VA_ARGS__)
#define Skeleton_dispose(...) spSkeleton_dispose(__VA_ARGS__)
#define Skeleton_updateWorldTransform(...) spSkeleton_updateWorldTransform(__VA_ARGS__)
#define Skeleton_setToSetupPose(...) spSkeleton_setToSetupPose(__VA_ARGS__)
#define Skeleton_setBonesToSetupPose(...) spSkeleton_setBonesToSetupPose(__VA_ARGS__)
#define Skeleton_setSlotsToSetupPose(...) spSkeleton_setSlotsToSetupPose(__VA_ARGS__)
#define Skeleton_findBone(...) spSkeleton_findBone(__VA_ARGS__)
#define Skeleton_findBoneIndex(...) spSkeleton_findBoneIndex(__VA_ARGS__)
#define Skeleton_findSlot(...) spSkeleton_findSlot(__VA_ARGS__)
#define Skeleton_findSlotIndex(...) spSkeleton_findSlotIndex(__VA_ARGS__)
#define Skeleton_setSkin(...) spSkeleton_setSkin(__VA_ARGS__)
#define Skeleton_setSkinByName(...) spSkeleton_setSkinByName(__VA_ARGS__)
#define Skeleton_getAttachmentForSlotName(...) spSkeleton_getAttachmentForSlotName(__VA_ARGS__)
#define Skeleton_getAttachmentForSlotIndex(...) spSkeleton_getAttachmentForSlotIndex(__VA_ARGS__)
#define Skeleton_setAttachment(...) spSkeleton_setAttachment(__VA_ARGS__)
#define Skeleton_update(...) spSkeleton_update(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

59
spine-c/include/spine/SkeletonBounds.h
View File

@ -45,47 +45,68 @@ typedef struct {
float* const vertices;
int count;
int capacity;
} BoundingPolygon;
} spBoundingPolygon;
BoundingPolygon* BoundingPolygon_create (int capacity);
void BoundingPolygon_dispose (BoundingPolygon* self);
spBoundingPolygon* spBoundingPolygon_create (int capacity);
void spBoundingPolygon_dispose (spBoundingPolygon* self);
int/*bool*/BoundingPolygon_containsPoint (BoundingPolygon* polygon, float x, float y);
int/*bool*/BoundingPolygon_intersectsSegment (BoundingPolygon* polygon, float x1, float y1, float x2, float y2);
int/*bool*/spBoundingPolygon_containsPoint (spBoundingPolygon* polygon, float x, float y);
int/*bool*/spBoundingPolygon_intersectsSegment (spBoundingPolygon* polygon, float x1, float y1, float x2, float y2);
#ifdef SPINE_SHORT_NAMES
typedef spBoundingPolygon BoundingPolygon;
#define BoundingPolygon_create(...) spBoundingPolygon_create(__VA_ARGS__)
#define BoundingPolygon_dispose(...) spBoundingPolygon_dispose(__VA_ARGS__)
#define BoundingPolygon_containsPoint(...) spBoundingPolygon_containsPoint(__VA_ARGS__)
#define BoundingPolygon_intersectsSegment(...) spBoundingPolygon_intersectsSegment(__VA_ARGS__)
#endif
/**/
typedef struct {
int count;
BoundingBoxAttachment** boundingBoxes;
BoundingPolygon** polygons;
spBoundingBoxAttachment** boundingBoxes;
spBoundingPolygon** polygons;
float minX, minY, maxX, maxY;
} SkeletonBounds;
} spSkeletonBounds;
SkeletonBounds* SkeletonBounds_create ();
void SkeletonBounds_dispose (SkeletonBounds* self);
void SkeletonBounds_update (SkeletonBounds* self, Skeleton* skeleton, int/*bool*/updateAabb);
spSkeletonBounds* spSkeletonBounds_create ();
void spSkeletonBounds_dispose (spSkeletonBounds* self);
void spSkeletonBounds_update (spSkeletonBounds* self, spSkeleton* skeleton, int/*bool*/updateAabb);
/** Returns true if the axis aligned bounding box contains the point. */
int/*bool*/SkeletonBounds_aabbContainsPoint (SkeletonBounds* self, float x, float y);
int/*bool*/spSkeletonBounds_aabbContainsPoint (spSkeletonBounds* self, float x, float y);
/** Returns true if the axis aligned bounding box intersects the line segment. */
int/*bool*/SkeletonBounds_aabbIntersectsSegment (SkeletonBounds* self, float x1, float y1, float x2, float y2);
int/*bool*/spSkeletonBounds_aabbIntersectsSegment (spSkeletonBounds* self, float x1, float y1, float x2, float y2);
/** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
int/*bool*/SkeletonBounds_aabbIntersectsSkeleton (SkeletonBounds* self, SkeletonBounds* bounds);
int/*bool*/spSkeletonBounds_aabbIntersectsSkeleton (spSkeletonBounds* self, spSkeletonBounds* bounds);
/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
* efficient to only call this method if SkeletonBounds_aabbContainsPoint returns true. */
BoundingBoxAttachment* SkeletonBounds_containsPoint (SkeletonBounds* self, float x, float y);
* efficient to only call this method if spSkeletonBounds_aabbContainsPoint returns true. */
spBoundingBoxAttachment* spSkeletonBounds_containsPoint (spSkeletonBounds* self, float x, float y);
/** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
* more efficient to only call this method if SkeletonBounds_aabbIntersectsSegment returns true. */
BoundingBoxAttachment* SkeletonBounds_intersectsSegment (SkeletonBounds* self, float x1, float y1, float x2, float y2);
* more efficient to only call this method if spSkeletonBounds_aabbIntersectsSegment returns true. */
spBoundingBoxAttachment* spSkeletonBounds_intersectsSegment (spSkeletonBounds* self, float x1, float y1, float x2, float y2);
/** Returns the polygon for the specified bounding box, or null. */
BoundingPolygon* SkeletonBounds_getPolygon (SkeletonBounds* self, BoundingBoxAttachment* boundingBox);
spBoundingPolygon* spSkeletonBounds_getPolygon (spSkeletonBounds* self, spBoundingBoxAttachment* boundingBox);
#ifdef SPINE_SHORT_NAMES
typedef spSkeletonBounds SkeletonBounds;
#define SkeletonBounds_create(...) spSkeletonBounds_create(__VA_ARGS__)
#define SkeletonBounds_dispose(...) spSkeletonBounds_dispose(__VA_ARGS__)
#define SkeletonBounds_update(...) spSkeletonBounds_update(__VA_ARGS__)
#define SkeletonBounds_aabbContainsPoint(...) spSkeletonBounds_aabbContainsPoint(__VA_ARGS__)
#define SkeletonBounds_aabbIntersectsSegment(...) spSkeletonBounds_aabbIntersectsSegment(__VA_ARGS__)
#define SkeletonBounds_aabbIntersectsSkeleton(...) spSkeletonBounds_aabbIntersectsSkeleton(__VA_ARGS__)
#define SkeletonBounds_containsPoint(...) spSkeletonBounds_containsPoint(__VA_ARGS__)
#define SkeletonBounds_intersectsSegment(...) spSkeletonBounds_intersectsSegment(__VA_ARGS__)
#define SkeletonBounds_getPolygon(...) spSkeletonBounds_getPolygon(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

45
spine-c/include/spine/SkeletonData.h
View File

@ -46,36 +46,49 @@ extern "C" {
typedef struct {
int boneCount;
BoneData** bones;
spBoneData** bones;
int slotCount;
SlotData** slots;
spSlotData** slots;
int skinCount;
Skin** skins;
Skin* defaultSkin;
spSkin** skins;
spSkin* defaultSkin;
int eventCount;
EventData** events;
spEventData** events;
int animationCount;
Animation** animations;
} SkeletonData;
spAnimation** animations;
} spSkeletonData;
SkeletonData* SkeletonData_create ();
void SkeletonData_dispose (SkeletonData* self);
spSkeletonData* spSkeletonData_create ();
void spSkeletonData_dispose (spSkeletonData* self);
BoneData* SkeletonData_findBone (const SkeletonData* self, const char* boneName);
int SkeletonData_findBoneIndex (const SkeletonData* self, const char* boneName);
spBoneData* spSkeletonData_findBone (const spSkeletonData* self, const char* boneName);
int spSkeletonData_findBoneIndex (const spSkeletonData* self, const char* boneName);
SlotData* SkeletonData_findSlot (const SkeletonData* self, const char* slotName);
int SkeletonData_findSlotIndex (const SkeletonData* self, const char* slotName);
spSlotData* spSkeletonData_findSlot (const spSkeletonData* self, const char* slotName);
int spSkeletonData_findSlotIndex (const spSkeletonData* self, const char* slotName);
Skin* SkeletonData_findSkin (const SkeletonData* self, const char* skinName);
spSkin* spSkeletonData_findSkin (const spSkeletonData* self, const char* skinName);
EventData* SkeletonData_findEvent (const SkeletonData* self, const char* eventName);
spEventData* spSkeletonData_findEvent (const spSkeletonData* self, const char* eventName);
Animation* SkeletonData_findAnimation (const SkeletonData* self, const char* animationName);
spAnimation* spSkeletonData_findAnimation (const spSkeletonData* self, const char* animationName);
#ifdef SPINE_SHORT_NAMES
typedef spSkeletonData SkeletonData;
#define SkeletonData_create(...) spSkeletonData_create(__VA_ARGS__)
#define SkeletonData_dispose(...) spSkeletonData_dispose(__VA_ARGS__)
#define SkeletonData_findBone(...) spSkeletonData_findBone(__VA_ARGS__)
#define SkeletonData_findBoneIndex(...) spSkeletonData_findBoneIndex(__VA_ARGS__)
#define SkeletonData_findSlot(...) spSkeletonData_findSlot(__VA_ARGS__)
#define SkeletonData_findSlotIndex(...) spSkeletonData_findSlotIndex(__VA_ARGS__)
#define SkeletonData_findSkin(...) spSkeletonData_findSkin(__VA_ARGS__)
#define SkeletonData_findEvent(...) spSkeletonData_findEvent(__VA_ARGS__)
#define SkeletonData_findAnimation(...) spSkeletonData_findAnimation(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

23
spine-c/include/spine/SkeletonJson.h
View File

@ -46,16 +46,25 @@ extern "C" {
typedef struct {
float scale;
AttachmentLoader* attachmentLoader;
spAttachmentLoader* attachmentLoader;
const char* const error;
} SkeletonJson;
} spSkeletonJson;
SkeletonJson* SkeletonJson_createWithLoader (AttachmentLoader* attachmentLoader);
SkeletonJson* SkeletonJson_create (Atlas* atlas);
void SkeletonJson_dispose (SkeletonJson* self);
spSkeletonJson* spSkeletonJson_createWithLoader (spAttachmentLoader* attachmentLoader);
spSkeletonJson* spSkeletonJson_create (spAtlas* atlas);
void spSkeletonJson_dispose (spSkeletonJson* self);
SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* json);
SkeletonData* SkeletonJson_readSkeletonDataFile (SkeletonJson* self, const char* path);
spSkeletonData* spSkeletonJson_readSkeletonData (spSkeletonJson* self, const char* json);
spSkeletonData* spSkeletonJson_readSkeletonDataFile (spSkeletonJson* self, const char* path);
#ifdef SPINE_SHORT_NAMES
typedef spSkeletonJson SkeletonJson;
#define SkeletonJson_createWithLoader(...) spSkeletonJson_createWithLoader(__VA_ARGS__)
#define SkeletonJson_create(...) spSkeletonJson_create(__VA_ARGS__)
#define SkeletonJson_dispose(...) spSkeletonJson_dispose(__VA_ARGS__)
#define SkeletonJson_readSkeletonData(...) spSkeletonJson_readSkeletonData(__VA_ARGS__)
#define SkeletonJson_readSkeletonDataFile(...) spSkeletonJson_readSkeletonDataFile(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

26
spine-c/include/spine/Skin.h
View File

@ -40,25 +40,35 @@
extern "C" {
#endif
struct Skeleton;
struct spSkeleton;
typedef struct {
const char* const name;
} Skin;
} spSkin;
Skin* Skin_create (const char* name);
void Skin_dispose (Skin* self);
spSkin* spSkin_create (const char* name);
void spSkin_dispose (spSkin* self);
/* The Skin owns the attachment. */
void Skin_addAttachment (Skin* self, int slotIndex, const char* name, Attachment* attachment);
void spSkin_addAttachment (spSkin* self, int slotIndex, const char* name, spAttachment* attachment);
/* Returns 0 if the attachment was not found. */
Attachment* Skin_getAttachment (const Skin* self, int slotIndex, const char* name);
spAttachment* spSkin_getAttachment (const spSkin* self, int slotIndex, const char* name);
/* Returns 0 if the slot or attachment was not found. */
const char* Skin_getAttachmentName (const Skin* self, int slotIndex, int attachmentIndex);
const char* spSkin_getAttachmentName (const spSkin* self, int slotIndex, int attachmentIndex);
/** Attach each attachment in this skin if the corresponding attachment in oldSkin is currently attached. */
void Skin_attachAll (const Skin* self, struct Skeleton* skeleton, const Skin* oldSkin);
void spSkin_attachAll (const spSkin* self, struct spSkeleton* skeleton, const spSkin* oldspSkin);
#ifdef SPINE_SHORT_NAMES
typedef spSkin Skin;
#define Skin_create(...) spSkin_create(__VA_ARGS__)
#define Skin_dispose(...) spSkin_dispose(__VA_ARGS__)
#define Skin_addAttachment(...) spSkin_addAttachment(__VA_ARGS__)
#define Skin_getAttachment(...) spSkin_getAttachment(__VA_ARGS__)
#define Skin_getAttachmentName(...) spSkin_getAttachmentName(__VA_ARGS__)
#define Skin_attachAll(...) spSkin_attachAll(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

36
spine-c/include/spine/Slot.h
View File

@ -42,26 +42,36 @@
extern "C" {
#endif
struct Skeleton;
struct spSkeleton;
typedef struct Slot {
SlotData* const data;
struct Skeleton* const skeleton;
Bone* const bone;
typedef struct spSlot {
spSlotData* const data;
struct spSkeleton* const skeleton;
spBone* const bone;
float r, g, b, a;
Attachment* const attachment;
} Slot;
spAttachment* const attachment;
} spSlot;
Slot* Slot_create (SlotData* data, struct Skeleton* skeleton, Bone* bone);
void Slot_dispose (Slot* self);
spSlot* spSlot_create (spSlotData* data, struct spSkeleton* skeleton, spBone* bone);
void spSlot_dispose (spSlot* self);
/* @param attachment May be 0 to clear the attachment for the slot. */
void Slot_setAttachment (Slot* self, Attachment* attachment);
void spSlot_setAttachment (spSlot* self, spAttachment* attachment);
void Slot_setAttachmentTime (Slot* self, float time);
float Slot_getAttachmentTime (const Slot* self);
void spSlot_setAttachmentTime (spSlot* self, float time);
float spSlot_getAttachmentTime (const spSlot* self);
void Slot_setToSetupPose (Slot* self);
void spSlot_setToSetupPose (spSlot* self);
#ifdef SPINE_SHORT_NAMES
typedef spSlot Slot;
#define Slot_create(...) spSlot_create(__VA_ARGS__)
#define Slot_dispose(...) spSlot_dispose(__VA_ARGS__)
#define Slot_setAttachment(...) spSlot_setAttachment(__VA_ARGS__)
#define Slot_setAttachmentTime(...) spSlot_setAttachmentTime(__VA_ARGS__)
#define Slot_getAttachmentTime(...) spSlot_getAttachmentTime(__VA_ARGS__)
#define Slot_setToSetupPose(...) spSlot_setToSetupPose(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

17
spine-c/include/spine/SlotData.h
View File

@ -42,17 +42,24 @@ extern "C" {
typedef struct {
const char* const name;
const BoneData* const boneData;
const spBoneData* const boneData;
const char* const attachmentName;
float r, g, b, a;
int/*bool*/additiveBlending;
} SlotData;
} spSlotData;
SlotData* SlotData_create (const char* name, BoneData* boneData);
void SlotData_dispose (SlotData* self);
spSlotData* spSlotData_create (const char* name, spBoneData* boneData);
void spSlotData_dispose (spSlotData* self);
/* @param attachmentName May be 0 for no setup pose attachment. */
void SlotData_setAttachmentName (SlotData* self, const char* attachmentName);
void spSlotData_setAttachmentName (spSlotData* self, const char* attachmentName);
#ifdef SPINE_SHORT_NAMES
typedef spSlotData SlotData;
#define SlotData_create(...) spSlotData_create(__VA_ARGS__)
#define SlotData_dispose(...) spSlotData_dispose(__VA_ARGS__)
#define SlotData_setAttachmentName(...) spSlotData_setAttachmentName(__VA_ARGS__)
#endif
#ifdef __cplusplus
}

79
spine-c/include/spine/extension.h
View File

@ -1,5 +1,4 @@
/*
Implementation notes:
@ -58,9 +57,9 @@
#define MALLOC_STR(TO,FROM) strcpy(CONST_CAST(char*, TO) = (char*)malloc(strlen(FROM) + 1), FROM)
#ifdef __STDC_VERSION__
#define FMOD(A,B) fmodf(A, B)
#define FMOD(A,B) fmodf(A, B)
#else
#define FMOD(A,B) (float)fmod(A, B)
#define FMOD(A,B) (float)fmod(A, B)
#endif
#include <stdlib.h>
@ -81,9 +80,15 @@ extern "C" {
* Functions that must be implemented:
*/
void _AtlasPage_createTexture (AtlasPage* self, const char* path);
void _AtlasPage_disposeTexture (AtlasPage* self);
char* _Util_readFile (const char* path, int* length);
void _spAtlasPage_createTexture (spAtlasPage* self, const char* path);
void _spAtlasPage_disposeTexture (spAtlasPage* self);
char* _spUtil_readFile (const char* path, int* length);
#ifdef SPINE_SHORT_NAMES
#define _AtlasPage_createTexture(...) _spAtlasPage_createTexture(__VA_ARGS__)
#define _AtlasPage_disposeTexture(...) _spAtlasPage_disposeTexture(__VA_ARGS__)
#define _Util_readFile(...) _spUtil_readFile(__VA_ARGS__)
#endif
/*
* Internal API available for extension:
@ -100,37 +105,59 @@ char* _readFile (const char* path, int* length);
/**/
void _AttachmentLoader_init (AttachmentLoader* self, /**/
void (*dispose) (AttachmentLoader* self), /**/
Attachment* (*newAttachment) (AttachmentLoader* self, Skin* skin, AttachmentType type, const char* name));
void _AttachmentLoader_deinit (AttachmentLoader* self);
void _AttachmentLoader_setError (AttachmentLoader* self, const char* error1, const char* error2);
void _AttachmentLoader_setUnknownTypeError (AttachmentLoader* self, AttachmentType type);
void _spAttachmentLoader_init (spAttachmentLoader* self, /**/
void (*dispose) (spAttachmentLoader* self), /**/
spAttachment* (*newAttachment) (spAttachmentLoader* self, spSkin* skin, spAttachmentType type, const char* name));
void _spAttachmentLoader_deinit (spAttachmentLoader* self);
void _spAttachmentLoader_setError (spAttachmentLoader* self, const char* error1, const char* error2);
void _spAttachmentLoader_setUnknownTypeError (spAttachmentLoader* self, spAttachmentType type);
#ifdef SPINE_SHORT_NAMES
#define _AttachmentLoader_init(...) _spAttachmentLoader_init(__VA_ARGS__)
#define _AttachmentLoader_deinit(...) _spAttachmentLoader_deinit(__VA_ARGS__)
#define _AttachmentLoader_setError(...) _spAttachmentLoader_setError(__VA_ARGS__)
#define _AttachmentLoader_setUnknownTypeError(...) _spAttachmentLoader_setUnknownTypeError(__VA_ARGS__)
#endif
/**/
void _Attachment_init (Attachment* self, const char* name, AttachmentType type, /**/
void (*dispose) (Attachment* self));
void _Attachment_deinit (Attachment* self);
void _spAttachment_init (spAttachment* self, const char* name, spAttachmentType type, /**/
void (*dispose) (spAttachment* self));
void _spAttachment_deinit (spAttachment* self);
#ifdef SPINE_SHORT_NAMES
#define _Attachment_init(...) _spAttachment_init(__VA_ARGS__)
#define _Attachment_deinit(...) _spAttachment_deinit(__VA_ARGS__)
#endif
/**/
void _Timeline_init (Timeline* self, /**/
void (*dispose) (Timeline* self), /**/
void (*apply) (const Timeline* self, Skeleton* skeleton, float lastTime, float time, Event** firedEvents, int* eventCount,
float alpha));
void _Timeline_deinit (Timeline* self);
void _spTimeline_init (spTimeline* self, /**/
void (*dispose) (spTimeline* self), /**/
void (*apply) (const spTimeline* self, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha));
void _spTimeline_deinit (spTimeline* self);
#ifdef SPINE_SHORT_NAMES
#define _Timeline_init(...) _spTimeline_init(__VA_ARGS__)
#define _Timeline_deinit(...) _spTimeline_deinit(__VA_ARGS__)
#endif
/**/
void _CurveTimeline_init (CurveTimeline* self, int frameCount, /**/
void (*dispose) (Timeline* self), /**/
void (*apply) (const Timeline* self, Skeleton* skeleton, float lastTime, float time, Event** firedEvents, int* eventCount,
float alpha));
void _CurveTimeline_deinit (CurveTimeline* self);
void _spCurveTimeline_init (spCurveTimeline* self, int frameCount, /**/
void (*dispose) (spTimeline* self), /**/
void (*apply) (const spTimeline* self, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha));
void _spCurveTimeline_deinit (spCurveTimeline* self);
#ifdef SPINE_SHORT_NAMES
#define _CurveTimeline_init(...) _spCurveTimeline_init(__VA_ARGS__)
#define _CurveTimeline_deinit(...) _spCurveTimeline_deinit(__VA_ARGS__)
#endif
#ifdef __cplusplus
}
#endif
#endif /* SPINE_EXTENSION_H_ */
#endif /* SPINE_EXTENSION_H_ */

68
spine-c/spine-c.vcxproj
View File

@ -71,53 +71,53 @@
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="include\spine\Animation.h" />
<ClInclude Include="include\spine\AnimationState.h" />
<ClInclude Include="include\spine\AnimationStateData.h" />
<ClInclude Include="include\spine\spAnimation.h" />
<ClInclude Include="include\spine\spAnimationState.h" />
<ClInclude Include="include\spine\spAnimationStateData.h" />
<ClInclude Include="include\spine\Atlas.h" />
<ClInclude Include="include\spine\AtlasAttachmentLoader.h" />
<ClInclude Include="include\spine\spAtlasAttachmentLoader.h" />
<ClInclude Include="include\spine\Attachment.h" />
<ClInclude Include="include\spine\AttachmentLoader.h" />
<ClInclude Include="include\spine\Bone.h" />
<ClInclude Include="include\spine\BoneData.h" />
<ClInclude Include="include\spine\BoundingBoxAttachment.h" />
<ClInclude Include="include\spine\Event.h" />
<ClInclude Include="include\spine\EventData.h" />
<ClInclude Include="include\spine\spAttachmentLoader.h" />
<ClInclude Include="include\spine\spBone.h" />
<ClInclude Include="include\spine\spBoneData.h" />
<ClInclude Include="include\spine\spBoundingBoxAttachment.h" />
<ClInclude Include="include\spine\spEvent.h" />
<ClInclude Include="include\spine\spEventData.h" />
<ClInclude Include="include\spine\extension.h" />
<ClInclude Include="include\spine\RegionAttachment.h" />
<ClInclude Include="include\spine\spRegionAttachment.h" />
<ClInclude Include="include\spine\Skeleton.h" />
<ClInclude Include="include\spine\SkeletonBounds.h" />
<ClInclude Include="include\spine\SkeletonData.h" />
<ClInclude Include="include\spine\SkeletonJson.h" />
<ClInclude Include="include\spine\Skin.h" />
<ClInclude Include="include\spine\Slot.h" />
<ClInclude Include="include\spine\SlotData.h" />
<ClInclude Include="include\spine\spSkeletonBounds.h" />
<ClInclude Include="include\spine\spSkeletonData.h" />
<ClInclude Include="include\spine\spSkeletonJson.h" />
<ClInclude Include="include\spine\spSkin.h" />
<ClInclude Include="include\spine\spSlot.h" />
<ClInclude Include="include\spine\spSlotData.h" />
<ClInclude Include="include\spine\spine.h" />
<ClInclude Include="src\spine\Json.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\spine\Animation.c" />
<ClCompile Include="src\spine\AnimationState.c" />
<ClCompile Include="src\spine\AnimationStateData.c" />
<ClCompile Include="src\spine\spAnimation.c" />
<ClCompile Include="src\spine\spAnimationState.c" />
<ClCompile Include="src\spine\spAnimationStateData.c" />
<ClCompile Include="src\spine\Atlas.c" />
<ClCompile Include="src\spine\AtlasAttachmentLoader.c" />
<ClCompile Include="src\spine\AtlasspAttachmentLoader.c" />
<ClCompile Include="src\spine\Attachment.c" />
<ClCompile Include="src\spine\AttachmentLoader.c" />
<ClCompile Include="src\spine\Bone.c" />
<ClCompile Include="src\spine\BoneData.c" />
<ClCompile Include="src\spine\BoundingBoxAttachment.c" />
<ClCompile Include="src\spine\Event.c" />
<ClCompile Include="src\spine\EventData.c" />
<ClCompile Include="src\spine\spAttachmentLoader.c" />
<ClCompile Include="src\spine\spBone.c" />
<ClCompile Include="src\spine\spBoneData.c" />
<ClCompile Include="src\spine\spBoundingBoxAttachment.c" />
<ClCompile Include="src\spine\spEvent.c" />
<ClCompile Include="src\spine\spEventData.c" />
<ClCompile Include="src\spine\extension.c" />
<ClCompile Include="src\spine\Json.c" />
<ClCompile Include="src\spine\RegionAttachment.c" />
<ClCompile Include="src\spine\spRegionAttachment.c" />
<ClCompile Include="src\spine\Skeleton.c" />
<ClCompile Include="src\spine\SkeletonBounds.c" />
<ClCompile Include="src\spine\SkeletonData.c" />
<ClCompile Include="src\spine\SkeletonJson.c" />
<ClCompile Include="src\spine\Skin.c" />
<ClCompile Include="src\spine\Slot.c" />
<ClCompile Include="src\spine\SlotData.c" />
<ClCompile Include="src\spine\spSkeletonBounds.c" />
<ClCompile Include="src\spine\spSkeletonData.c" />
<ClCompile Include="src\spine\spSkeletonJson.c" />
<ClCompile Include="src\spine\spSkin.c" />
<ClCompile Include="src\spine\spSlot.c" />
<ClCompile Include="src\spine\spSlotData.c" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

68
spine-c/spine-c.vcxproj.filters
View File

@ -15,55 +15,55 @@
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\spine\Animation.h">
<ClInclude Include="include\spine\spAnimation.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\AnimationState.h">
<ClInclude Include="include\spine\spAnimationState.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\AnimationStateData.h">
<ClInclude Include="include\spine\spAnimationStateData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\Atlas.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\AtlasAttachmentLoader.h">
<ClInclude Include="include\spine\spAtlasAttachmentLoader.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\Attachment.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\AttachmentLoader.h">
<ClInclude Include="include\spine\spAttachmentLoader.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\Bone.h">
<ClInclude Include="include\spine\spBone.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\BoneData.h">
<ClInclude Include="include\spine\spBoneData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\extension.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\RegionAttachment.h">
<ClInclude Include="include\spine\spRegionAttachment.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\Skeleton.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\SkeletonData.h">
<ClInclude Include="include\spine\spSkeletonData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\SkeletonJson.h">
<ClInclude Include="include\spine\spSkeletonJson.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\Skin.h">
<ClInclude Include="include\spine\spSkin.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\Slot.h">
<ClInclude Include="include\spine\spSlot.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\SlotData.h">
<ClInclude Include="include\spine\spSlotData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\spine.h">
@ -72,45 +72,45 @@
<ClInclude Include="src\spine\Json.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\BoundingBoxAttachment.h">
<ClInclude Include="include\spine\spBoundingBoxAttachment.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\SkeletonBounds.h">
<ClInclude Include="include\spine\spSkeletonBounds.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\Event.h">
<ClInclude Include="include\spine\spEvent.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\spine\EventData.h">
<ClInclude Include="include\spine\spEventData.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\spine\Animation.c">
<ClCompile Include="src\spine\spAnimation.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\AnimationState.c">
<ClCompile Include="src\spine\spAnimationState.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\AnimationStateData.c">
<ClCompile Include="src\spine\spAnimationStateData.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\Atlas.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\AtlasAttachmentLoader.c">
<ClCompile Include="src\spine\spAtlasAttachmentLoader.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\Attachment.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\AttachmentLoader.c">
<ClCompile Include="src\spine\spAttachmentLoader.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\Bone.c">
<ClCompile Include="src\spine\spBone.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\BoneData.c">
<ClCompile Include="src\spine\spBoneData.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\extension.c">
@ -119,37 +119,37 @@
<ClCompile Include="src\spine\Json.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\RegionAttachment.c">
<ClCompile Include="src\spine\spRegionAttachment.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\Skeleton.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\SkeletonData.c">
<ClCompile Include="src\spine\spSkeletonData.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\SkeletonJson.c">
<ClCompile Include="src\spine\spSkeletonJson.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\Skin.c">
<ClCompile Include="src\spine\spSkin.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\Slot.c">
<ClCompile Include="src\spine\spSlot.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\SlotData.c">
<ClCompile Include="src\spine\spSlotData.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\BoundingBoxAttachment.c">
<ClCompile Include="src\spine\spBoundingBoxAttachment.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\SkeletonBounds.c">
<ClCompile Include="src\spine\spSkeletonBounds.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\EventData.c">
<ClCompile Include="src\spine\spEventData.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\spine\Event.c">
<ClCompile Include="src\spine\spEvent.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>

212
spine-c/src/spine/Animation.c
View File

@ -35,24 +35,24 @@
#include <limits.h>
#include <spine/extension.h>
Animation* Animation_create (const char* name, int timelineCount) {
Animation* self = NEW(Animation);
spAnimation* spAnimation_create (const char* name, int timelineCount) {
spAnimation* self = NEW(spAnimation);
MALLOC_STR(self->name, name);
self->timelineCount = timelineCount;
self->timelines = MALLOC(Timeline*, timelineCount);
self->timelines = MALLOC(spTimeline*, timelineCount);
return self;
}
void Animation_dispose (Animation* self) {
void spAnimation_dispose (spAnimation* self) {
int i;
for (i = 0; i < self->timelineCount; ++i)
Timeline_dispose(self->timelines[i]);
spTimeline_dispose(self->timelines[i]);
FREE(self->timelines);
FREE(self->name);
FREE(self);
}
void Animation_apply (const Animation* self, Skeleton* skeleton, float lastTime, float time, int loop, Event** events,
void spAnimation_apply (const spAnimation* self, spSkeleton* skeleton, float lastTime, float time, int loop, spEvent** events,
int* eventCount) {
int i, n = self->timelineCount;
@ -62,10 +62,10 @@ void Animation_apply (const Animation* self, Skeleton* skeleton, float lastTime,
}
for (i = 0; i < n; ++i)
Timeline_apply(self->timelines[i], skeleton, lastTime, time, events, eventCount, 1);
spTimeline_apply(self->timelines[i], skeleton, lastTime, time, events, eventCount, 1);
}
void Animation_mix (const Animation* self, Skeleton* skeleton, float lastTime, float time, int loop, Event** events,
void spAnimation_mix (const spAnimation* self, spSkeleton* skeleton, float lastTime, float time, int loop, spEvent** events,
int* eventCount, float alpha) {
int i, n = self->timelineCount;
@ -75,37 +75,37 @@ void Animation_mix (const Animation* self, Skeleton* skeleton, float lastTime, f
}
for (i = 0; i < n; ++i)
Timeline_apply(self->timelines[i], skeleton, lastTime, time, events, eventCount, alpha);
spTimeline_apply(self->timelines[i], skeleton, lastTime, time, events, eventCount, alpha);
}
/**/
typedef struct _TimelineVtable {
void (*apply) (const Timeline* self, Skeleton* skeleton, float lastTime, float time, Event** firedEvents, int* eventCount,
typedef struct _spTimelineVtable {
void (*apply) (const spTimeline* self, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents, int* eventCount,
float alpha);
void (*dispose) (Timeline* self);
} _TimelineVtable;
void (*dispose) (spTimeline* self);
} _spTimelineVtable;
void _Timeline_init (Timeline* self, /**/
void (*dispose) (Timeline* self), /**/
void (*apply) (const Timeline* self, Skeleton* skeleton, float lastTime, float time, Event** firedEvents, int* eventCount,
float alpha)) {
CONST_CAST(_TimelineVtable*, self->vtable) = NEW(_TimelineVtable);
VTABLE(Timeline, self)->dispose = dispose;
VTABLE(Timeline, self)->apply = apply;
void _spTimeline_init (spTimeline* self, /**/
void (*dispose) (spTimeline* self), /**/
void (*apply) (const spTimeline* self, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha)) {
CONST_CAST(_spTimelineVtable*, self->vtable) = NEW(_spTimelineVtable);
VTABLE(spTimeline, self)->dispose = dispose;
VTABLE(spTimeline, self)->apply = apply;
}
void _Timeline_deinit (Timeline* self) {
void _spTimeline_deinit (spTimeline* self) {
FREE(self->vtable);
}
void Timeline_dispose (Timeline* self) {
VTABLE(Timeline, self)->dispose(self);
void spTimeline_dispose (spTimeline* self) {
VTABLE(spTimeline, self)->dispose(self);
}
void Timeline_apply (const Timeline* self, Skeleton* skeleton, float lastTime, float time, Event** firedEvents, int* eventCount,
float alpha) {
VTABLE(Timeline, self)->apply(self, skeleton, lastTime, time, firedEvents, eventCount, alpha);
void spTimeline_apply (const spTimeline* self, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
VTABLE(spTimeline, self)->apply(self, skeleton, lastTime, time, firedEvents, eventCount, alpha);
}
/**/
@ -114,28 +114,28 @@ static const float CURVE_LINEAR = 0;
static const float CURVE_STEPPED = -1;
static const int CURVE_SEGMENTS = 10;
void _CurveTimeline_init (CurveTimeline* self, int frameCount, /**/
void (*dispose) (Timeline* self), /**/
void (*apply) (const Timeline* self, Skeleton* skeleton, float lastTime, float time, Event** firedEvents, int* eventCount,
float alpha)) {
_Timeline_init(SUPER(self), dispose, apply);
void _spCurveTimeline_init (spCurveTimeline* self, int frameCount, /**/
void (*dispose) (spTimeline* self), /**/
void (*apply) (const spTimeline* self, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha)) {
_spTimeline_init(SUPER(self), dispose, apply);
self->curves = CALLOC(float, (frameCount - 1) * 6);
}
void _CurveTimeline_deinit (CurveTimeline* self) {
_Timeline_deinit(SUPER(self));
void _spCurveTimeline_deinit (spCurveTimeline* self) {
_spTimeline_deinit(SUPER(self));
FREE(self->curves);
}
void CurveTimeline_setLinear (CurveTimeline* self, int frameIndex) {
void spCurveTimeline_setLinear (spCurveTimeline* self, int frameIndex) {
self->curves[frameIndex * 6] = CURVE_LINEAR;
}
void CurveTimeline_setStepped (CurveTimeline* self, int frameIndex) {
void spCurveTimeline_setStepped (spCurveTimeline* self, int frameIndex) {
self->curves[frameIndex * 6] = CURVE_STEPPED;
}
void CurveTimeline_setCurve (CurveTimeline* self, int frameIndex, float cx1, float cy1, float cx2, float cy2) {
void spCurveTimeline_setCurve (spCurveTimeline* self, int frameIndex, float cx1, float cy1, float cx2, float cy2) {
float subdiv_step = 1.0f / CURVE_SEGMENTS;
float subdiv_step2 = subdiv_step * subdiv_step;
float subdiv_step3 = subdiv_step2 * subdiv_step;
@ -156,7 +156,7 @@ void CurveTimeline_setCurve (CurveTimeline* self, int frameIndex, float cx1, flo
self->curves[i + 5] = tmp2y * pre5;
}
float CurveTimeline_getCurvePercent (const CurveTimeline* self, int frameIndex, float percent) {
float spCurveTimeline_getCurvePercent (const spCurveTimeline* self, int frameIndex, float percent) {
float dfy;
float ddfx;
float ddfy;
@ -221,19 +221,19 @@ static int binarySearch (float *values, int valuesLength, float target, int step
/**/
void _BaseTimeline_dispose (Timeline* timeline) {
struct BaseTimeline* self = SUB_CAST(struct BaseTimeline, timeline);
_CurveTimeline_deinit(SUPER(self));
void _spBaseTimeline_dispose (spTimeline* timeline) {
struct spBaseTimeline* self = SUB_CAST(struct spBaseTimeline, timeline);
_spCurveTimeline_deinit(SUPER(self));
FREE(self->frames);
FREE(self);
}
/* Many timelines have structure identical to struct BaseTimeline and extend CurveTimeline. **/
struct BaseTimeline* _BaseTimeline_create (int frameCount, int frameSize, /**/
void (*apply) (const Timeline* self, Skeleton* skeleton, float lastTime, float time, Event** firedEvents, int* eventCount,
float alpha)) {
struct BaseTimeline* self = NEW(struct BaseTimeline);
_CurveTimeline_init(SUPER(self), frameCount, _BaseTimeline_dispose, apply);
/* Many timelines have structure identical to struct spBaseTimeline and extend spCurveTimeline. **/
struct spBaseTimeline* _spBaseTimeline_create (int frameCount, int frameSize, /**/
void (*apply) (const spTimeline* self, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha)) {
struct spBaseTimeline* self = NEW(struct spBaseTimeline);
_spCurveTimeline_init(SUPER(self), frameCount, _spBaseTimeline_dispose, apply);
CONST_CAST(int, self->framesLength) = frameCount * frameSize;
CONST_CAST(float*, self->frames) = CALLOC(float, self->framesLength);
@ -246,13 +246,13 @@ struct BaseTimeline* _BaseTimeline_create (int frameCount, int frameSize, /**/
static const int ROTATE_LAST_FRAME_TIME = -2;
static const int ROTATE_FRAME_VALUE = 1;
void _RotateTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void _spRotateTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
Bone *bone;
spBone *bone;
int frameIndex;
float lastFrameValue, frameTime, percent, amount;
RotateTimeline* self = SUB_CAST(RotateTimeline, timeline);
spRotateTimeline* self = SUB_CAST(spRotateTimeline, timeline);
if (time < self->frames[0]) return; /* Time is before first frame. */
@ -273,7 +273,7 @@ void _RotateTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float
lastFrameValue = self->frames[frameIndex - 1];
frameTime = self->frames[frameIndex];
percent = 1 - (time - frameTime) / (self->frames[frameIndex + ROTATE_LAST_FRAME_TIME] - frameTime);
percent = CurveTimeline_getCurvePercent(SUPER(self), frameIndex / 2 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
percent = spCurveTimeline_getCurvePercent(SUPER(self), frameIndex / 2 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
amount = self->frames[frameIndex + ROTATE_FRAME_VALUE] - lastFrameValue;
while (amount > 180)
@ -288,11 +288,11 @@ void _RotateTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float
bone->rotation += amount * alpha;
}
RotateTimeline* RotateTimeline_create (int frameCount) {
return _BaseTimeline_create(frameCount, 2, _RotateTimeline_apply);
spRotateTimeline* spRotateTimeline_create (int frameCount) {
return _spBaseTimeline_create(frameCount, 2, _spRotateTimeline_apply);
}
void RotateTimeline_setFrame (RotateTimeline* self, int frameIndex, float time, float angle) {
void spRotateTimeline_setFrame (spRotateTimeline* self, int frameIndex, float time, float angle) {
frameIndex *= 2;
self->frames[frameIndex] = time;
self->frames[frameIndex + 1] = angle;
@ -304,13 +304,13 @@ static const int TRANSLATE_LAST_FRAME_TIME = -3;
static const int TRANSLATE_FRAME_X = 1;
static const int TRANSLATE_FRAME_Y = 2;
void _TranslateTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void _spTranslateTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
Bone *bone;
spBone *bone;
int frameIndex;
float lastFrameX, lastFrameY, frameTime, percent;
TranslateTimeline* self = SUB_CAST(TranslateTimeline, timeline);
spTranslateTimeline* self = SUB_CAST(spTranslateTimeline, timeline);
if (time < self->frames[0]) return; /* Time is before first frame. */
@ -328,7 +328,7 @@ void _TranslateTimeline_apply (const Timeline* timeline, Skeleton* skeleton, flo
lastFrameY = self->frames[frameIndex - 1];
frameTime = self->frames[frameIndex];
percent = 1 - (time - frameTime) / (self->frames[frameIndex + TRANSLATE_LAST_FRAME_TIME] - frameTime);
percent = CurveTimeline_getCurvePercent(SUPER(self), frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
percent = spCurveTimeline_getCurvePercent(SUPER(self), frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
bone->x += (bone->data->x + lastFrameX + (self->frames[frameIndex + TRANSLATE_FRAME_X] - lastFrameX) * percent - bone->x)
* alpha;
@ -336,11 +336,11 @@ void _TranslateTimeline_apply (const Timeline* timeline, Skeleton* skeleton, flo
* alpha;
}
TranslateTimeline* TranslateTimeline_create (int frameCount) {
return _BaseTimeline_create(frameCount, 3, _TranslateTimeline_apply);
spTranslateTimeline* spTranslateTimeline_create (int frameCount) {
return _spBaseTimeline_create(frameCount, 3, _spTranslateTimeline_apply);
}
void TranslateTimeline_setFrame (TranslateTimeline* self, int frameIndex, float time, float x, float y) {
void spTranslateTimeline_setFrame (spTranslateTimeline* self, int frameIndex, float time, float x, float y) {
frameIndex *= 3;
self->frames[frameIndex] = time;
self->frames[frameIndex + 1] = x;
@ -349,13 +349,13 @@ void TranslateTimeline_setFrame (TranslateTimeline* self, int frameIndex, float
/**/
void _ScaleTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void _spScaleTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
Bone *bone;
spBone *bone;
int frameIndex;
float lastFrameX, lastFrameY, frameTime, percent;
ScaleTimeline* self = SUB_CAST(ScaleTimeline, timeline);
spScaleTimeline* self = SUB_CAST(spScaleTimeline, timeline);
if (time < self->frames[0]) return; /* Time is before first frame. */
@ -372,7 +372,7 @@ void _ScaleTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float l
lastFrameY = self->frames[frameIndex - 1];
frameTime = self->frames[frameIndex];
percent = 1 - (time - frameTime) / (self->frames[frameIndex + TRANSLATE_LAST_FRAME_TIME] - frameTime);
percent = CurveTimeline_getCurvePercent(SUPER(self), frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
percent = spCurveTimeline_getCurvePercent(SUPER(self), frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
bone->scaleX += (bone->data->scaleX - 1 + lastFrameX + (self->frames[frameIndex + TRANSLATE_FRAME_X] - lastFrameX) * percent
- bone->scaleX) * alpha;
@ -380,12 +380,12 @@ void _ScaleTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float l
- bone->scaleY) * alpha;
}
ScaleTimeline* ScaleTimeline_create (int frameCount) {
return _BaseTimeline_create(frameCount, 3, _ScaleTimeline_apply);
spScaleTimeline* spScaleTimeline_create (int frameCount) {
return _spBaseTimeline_create(frameCount, 3, _spScaleTimeline_apply);
}
void ScaleTimeline_setFrame (ScaleTimeline* self, int frameIndex, float time, float x, float y) {
TranslateTimeline_setFrame(self, frameIndex, time, x, y);
void spScaleTimeline_setFrame (spScaleTimeline* self, int frameIndex, float time, float x, float y) {
spTranslateTimeline_setFrame(self, frameIndex, time, x, y);
}
/**/
@ -396,13 +396,13 @@ static const int COLOR_FRAME_G = 2;
static const int COLOR_FRAME_B = 3;
static const int COLOR_FRAME_A = 4;
void _ColorTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void _spColorTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
Slot *slot;
spSlot *slot;
int frameIndex;
float lastFrameR, lastFrameG, lastFrameB, lastFrameA, percent, frameTime;
float r, g, b, a;
ColorTimeline* self = (ColorTimeline*)timeline;
spColorTimeline* self = (spColorTimeline*)timeline;
if (time < self->frames[0]) return; /* Time is before first frame. */
@ -425,7 +425,7 @@ void _ColorTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float l
lastFrameA = self->frames[frameIndex - 1];
frameTime = self->frames[frameIndex];
percent = 1 - (time - frameTime) / (self->frames[frameIndex + COLOR_LAST_FRAME_TIME] - frameTime);
percent = CurveTimeline_getCurvePercent(SUPER(self), frameIndex / 5 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
percent = spCurveTimeline_getCurvePercent(SUPER(self), frameIndex / 5 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
r = lastFrameR + (self->frames[frameIndex + COLOR_FRAME_R] - lastFrameR) * percent;
g = lastFrameG + (self->frames[frameIndex + COLOR_FRAME_G] - lastFrameG) * percent;
@ -444,11 +444,11 @@ void _ColorTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float l
}
}
ColorTimeline* ColorTimeline_create (int frameCount) {
return (ColorTimeline*)_BaseTimeline_create(frameCount, 5, _ColorTimeline_apply);
spColorTimeline* spColorTimeline_create (int frameCount) {
return (spColorTimeline*)_spBaseTimeline_create(frameCount, 5, _spColorTimeline_apply);
}
void ColorTimeline_setFrame (ColorTimeline* self, int frameIndex, float time, float r, float g, float b, float a) {
void spColorTimeline_setFrame (spColorTimeline* self, int frameIndex, float time, float r, float g, float b, float a) {
frameIndex *= 5;
self->frames[frameIndex] = time;
self->frames[frameIndex + 1] = r;
@ -459,11 +459,11 @@ void ColorTimeline_setFrame (ColorTimeline* self, int frameIndex, float time, fl
/**/
void _AttachmentTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void _spAttachmentTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
int frameIndex;
const char* attachmentName;
AttachmentTimeline* self = (AttachmentTimeline*)timeline;
spAttachmentTimeline* self = (spAttachmentTimeline*)timeline;
if (time < self->frames[0]) return; /* Time is before first frame. */
@ -473,15 +473,15 @@ void _AttachmentTimeline_apply (const Timeline* timeline, Skeleton* skeleton, fl
frameIndex = binarySearch(self->frames, self->framesLength, time, 1) - 1;
attachmentName = self->attachmentNames[frameIndex];
Slot_setAttachment(skeleton->slots[self->slotIndex],
attachmentName ? Skeleton_getAttachmentForSlotIndex(skeleton, self->slotIndex, attachmentName) : 0);
spSlot_setAttachment(skeleton->slots[self->slotIndex],
attachmentName ? spSkeleton_getAttachmentForSlotIndex(skeleton, self->slotIndex, attachmentName) : 0);
}
void _AttachmentTimeline_dispose (Timeline* timeline) {
AttachmentTimeline* self = SUB_CAST(AttachmentTimeline, timeline);
void _spAttachmentTimeline_dispose (spTimeline* timeline) {
spAttachmentTimeline* self = SUB_CAST(spAttachmentTimeline, timeline);
int i;
_Timeline_deinit(timeline);
_spTimeline_deinit(timeline);
for (i = 0; i < self->framesLength; ++i)
FREE(self->attachmentNames[i]);
@ -490,9 +490,9 @@ void _AttachmentTimeline_dispose (Timeline* timeline) {
FREE(self);
}
AttachmentTimeline* AttachmentTimeline_create (int frameCount) {
AttachmentTimeline* self = NEW(AttachmentTimeline);
_Timeline_init(SUPER(self), _AttachmentTimeline_dispose, _AttachmentTimeline_apply);
spAttachmentTimeline* spAttachmentTimeline_create (int frameCount) {
spAttachmentTimeline* self = NEW(spAttachmentTimeline);
_spTimeline_init(SUPER(self), _spAttachmentTimeline_dispose, _spAttachmentTimeline_apply);
CONST_CAST(int, self->framesLength) = frameCount;
CONST_CAST(float*, self->frames) = CALLOC(float, frameCount);
@ -501,7 +501,7 @@ AttachmentTimeline* AttachmentTimeline_create (int frameCount) {
return self;
}
void AttachmentTimeline_setFrame (AttachmentTimeline* self, int frameIndex, float time, const char* attachmentName) {
void spAttachmentTimeline_setFrame (spAttachmentTimeline* self, int frameIndex, float time, const char* attachmentName) {
self->frames[frameIndex] = time;
FREE(self->attachmentNames[frameIndex]);
@ -513,17 +513,17 @@ void AttachmentTimeline_setFrame (AttachmentTimeline* self, int frameIndex, floa
/**/
void _EventTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void _spEventTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
if (!firedEvents) return;
EventTimeline* self = (EventTimeline*)timeline;
spEventTimeline* self = (spEventTimeline*)timeline;
int frameIndex;
if (lastTime >= self->frames[self->framesLength - 1]) return; /* Last time is after last frame. */
if (lastTime > time) {
/* Fire events after last time for looped animations. */
_EventTimeline_apply(timeline, skeleton, lastTime, (float)INT_MAX, firedEvents, eventCount, alpha);
_spEventTimeline_apply(timeline, skeleton, lastTime, (float)INT_MAX, firedEvents, eventCount, alpha);
lastTime = 0;
}
@ -544,11 +544,11 @@ void _EventTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float l
}
}
void _EventTimeline_dispose (Timeline* timeline) {
EventTimeline* self = SUB_CAST(EventTimeline, timeline);
void _spEventTimeline_dispose (spTimeline* timeline) {
spEventTimeline* self = SUB_CAST(spEventTimeline, timeline);
int i;
_Timeline_deinit(timeline);
_spTimeline_deinit(timeline);
for (i = 0; i < self->framesLength; ++i)
FREE(self->events[i]);
@ -557,18 +557,18 @@ void _EventTimeline_dispose (Timeline* timeline) {
FREE(self);
}
EventTimeline* EventTimeline_create (int frameCount) {
EventTimeline* self = NEW(EventTimeline);
_Timeline_init(SUPER(self), _EventTimeline_dispose, _EventTimeline_apply);
spEventTimeline* spEventTimeline_create (int frameCount) {
spEventTimeline* self = NEW(spEventTimeline);
_spTimeline_init(SUPER(self), _spEventTimeline_dispose, _spEventTimeline_apply);
CONST_CAST(int, self->framesLength) = frameCount;
CONST_CAST(float*, self->frames) = CALLOC(float, frameCount);
CONST_CAST(Event**, self->events) = CALLOC(Event*, frameCount);
CONST_CAST(spEvent**, self->events) = CALLOC(spEvent*, frameCount);
return self;
}
void EventTimeline_setFrame (EventTimeline* self, int frameIndex, float time, Event* event) {
void spEventTimeline_setFrame (spEventTimeline* self, int frameIndex, float time, spEvent* event) {
self->frames[frameIndex] = time;
FREE(self->events[frameIndex]);
@ -577,12 +577,12 @@ void EventTimeline_setFrame (EventTimeline* self, int frameIndex, float time, Ev
/**/
void _DrawOrderTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float lastTime, float time, Event** firedEvents,
void _spDrawOrderTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, float lastTime, float time, spEvent** firedEvents,
int* eventCount, float alpha) {
int i;
int frameIndex;
const int* drawOrderToSetupIndex;
DrawOrderTimeline* self = (DrawOrderTimeline*)timeline;
spDrawOrderTimeline* self = (spDrawOrderTimeline*)timeline;
if (time < self->frames[0]) return; /* Time is before first frame. */
@ -600,11 +600,11 @@ void _DrawOrderTimeline_apply (const Timeline* timeline, Skeleton* skeleton, flo
}
}
void _DrawOrderTimeline_dispose (Timeline* timeline) {
DrawOrderTimeline* self = SUB_CAST(DrawOrderTimeline, timeline);
void _spDrawOrderTimeline_dispose (spTimeline* timeline) {
spDrawOrderTimeline* self = SUB_CAST(spDrawOrderTimeline, timeline);
int i;
_Timeline_deinit(timeline);
_spTimeline_deinit(timeline);
for (i = 0; i < self->framesLength; ++i)
FREE(self->drawOrders[i]);
@ -613,9 +613,9 @@ void _DrawOrderTimeline_dispose (Timeline* timeline) {
FREE(self);
}
DrawOrderTimeline* DrawOrderTimeline_create (int frameCount, int slotCount) {
DrawOrderTimeline* self = NEW(DrawOrderTimeline);
_Timeline_init(SUPER(self), _DrawOrderTimeline_dispose, _DrawOrderTimeline_apply);
spDrawOrderTimeline* spDrawOrderTimeline_create (int frameCount, int slotCount) {
spDrawOrderTimeline* self = NEW(spDrawOrderTimeline);
_spTimeline_init(SUPER(self), _spDrawOrderTimeline_dispose, _spDrawOrderTimeline_apply);
CONST_CAST(int, self->framesLength) = frameCount;
CONST_CAST(float*, self->frames) = CALLOC(float, frameCount);
@ -625,7 +625,7 @@ DrawOrderTimeline* DrawOrderTimeline_create (int frameCount, int slotCount) {
return self;
}
void DrawOrderTimeline_setFrame (DrawOrderTimeline* self, int frameIndex, float time, const int* drawOrder) {
void spDrawOrderTimeline_setFrame (spDrawOrderTimeline* self, int frameIndex, float time, const int* drawOrder) {
self->frames[frameIndex] = time;
FREE(self->drawOrders[frameIndex]);

126
spine-c/src/spine/AnimationState.c
View File

@ -40,20 +40,20 @@
#include <spine/SkeletonData.h>
#include <string.h>
TrackEntry* _TrackEntry_create () {
TrackEntry* entry = NEW(TrackEntry);
spTrackEntry* _spTrackEntry_create () {
spTrackEntry* entry = NEW(spTrackEntry);
entry->timeScale = 1;
return entry;
}
void _TrackEntry_dispose (TrackEntry* entry) {
void _spTrackEntry_dispose (spTrackEntry* entry) {
FREE(entry);
}
void _TrackEntry_disposeAll (TrackEntry* entry) {
void _spTrackEntry_disposeAll (spTrackEntry* entry) {
while (entry) {
TrackEntry* next = entry->next;
_TrackEntry_dispose(entry);
spTrackEntry* next = entry->next;
_spTrackEntry_dispose(entry);
entry = next;
}
}
@ -61,34 +61,34 @@ void _TrackEntry_disposeAll (TrackEntry* entry) {
/**/
typedef struct {
AnimationState super;
Event** events;
} _AnimationState;
spAnimationState super;
spEvent** events;
} _spAnimationState;
void _AnimationState_setCurrent (AnimationState* self, int index, TrackEntry* entry);
void _spAnimationState_setCurrent (spAnimationState* self, int index, spTrackEntry* entry);
AnimationState* AnimationState_create (AnimationStateData* data) {
_AnimationState* internal = NEW(_AnimationState);
AnimationState* self = SUPER(internal);
internal->events = MALLOC(Event*, 64);
spAnimationState* spAnimationState_create (spAnimationStateData* data) {
_spAnimationState* internal = NEW(_spAnimationState);
spAnimationState* self = SUPER(internal);
internal->events = MALLOC(spEvent*, 64);
self->timeScale = 1;
CONST_CAST(AnimationStateData*, self->data) = data;
CONST_CAST(spAnimationStateData*, self->data) = data;
return self;
}
void AnimationState_dispose (AnimationState* self) {
void spAnimationState_dispose (spAnimationState* self) {
int i;
for (i = 0; i < self->trackCount; i++)
_TrackEntry_disposeAll(self->tracks[i]);
_spTrackEntry_disposeAll(self->tracks[i]);
FREE(self);
}
void AnimationState_update (AnimationState* self, float delta) {
void spAnimationState_update (spAnimationState* self, float delta) {
int i;
float time, endTime, trackDelta;
delta *= self->timeScale;
for (i = 0; i < self->trackCount; i++) {
TrackEntry* current = self->tracks[i];
spTrackEntry* current = self->tracks[i];
if (!current) continue;
trackDelta = delta * current->timeScale;
@ -110,23 +110,23 @@ void AnimationState_update (AnimationState* self, float delta) {
}
if (current->next) {
if (time - trackDelta >= current->next->delay) _AnimationState_setCurrent(self, i, current->next);
if (time - trackDelta >= current->next->delay) _spAnimationState_setCurrent(self, i, current->next);
} else {
/* End non-looping animation when it reaches its end time and there is no next entry. */
if (!current->loop && current->lastTime >= current->endTime) AnimationState_clearTrack(self, i);
if (!current->loop && current->lastTime >= current->endTime) spAnimationState_clearTrack(self, i);
}
}
}
void AnimationState_apply (AnimationState* self, Skeleton* skeleton) {
_AnimationState* internal = SUB_CAST(_AnimationState, self);
void spAnimationState_apply (spAnimationState* self, spSkeleton* skeleton) {
_spAnimationState* internal = SUB_CAST(_spAnimationState, self);
int i, ii;
int eventCount;
float time;
TrackEntry* previous;
spTrackEntry* previous;
for (i = 0; i < self->trackCount; i++) {
TrackEntry* current = self->tracks[i];
spTrackEntry* current = self->tracks[i];
if (!current) continue;
eventCount = 0;
@ -136,26 +136,26 @@ void AnimationState_apply (AnimationState* self, Skeleton* skeleton) {
previous = current->previous;
if (!previous) {
Animation_apply(current->animation, skeleton, current->lastTime, time, current->loop, internal->events,
spAnimation_apply(current->animation, skeleton, current->lastTime, time, current->loop, internal->events,
&eventCount);
} else {
float alpha = current->mixTime / current->mixDuration;
float previousTime = previous->time;
if (!previous->loop && previousTime > previous->endTime) previousTime = previous->endTime;
Animation_apply(previous->animation, skeleton, previousTime, previousTime, previous->loop, 0, 0);
spAnimation_apply(previous->animation, skeleton, previousTime, previousTime, previous->loop, 0, 0);
if (alpha >= 1) {
alpha = 1;
_TrackEntry_dispose(current->previous);
_spTrackEntry_dispose(current->previous);
current->previous = 0;
}
Animation_mix(current->animation, skeleton, current->lastTime, time, current->loop, internal->events,
spAnimation_mix(current->animation, skeleton, current->lastTime, time, current->loop, internal->events,
&eventCount, alpha);
}
for (ii = 0; ii < eventCount; ii++) {
Event* event = internal->events[ii];
spEvent* event = internal->events[ii];
if (current->listener) current->listener(self, i, ANIMATION_EVENT, event, 0);
if (self->listener) self->listener(self, i, ANIMATION_EVENT, event, 0);
}
@ -164,15 +164,15 @@ void AnimationState_apply (AnimationState* self, Skeleton* skeleton) {
}
}
void AnimationState_clearTracks (AnimationState* self) {
void spAnimationState_clearTracks (spAnimationState* self) {
int i;
for (i = 0; i < self->trackCount; i++)
AnimationState_clearTrack(self, i);
spAnimationState_clearTrack(self, i);
self->trackCount = 0;
}
void AnimationState_clearTrack (AnimationState* self, int trackIndex) {
TrackEntry* current;
void spAnimationState_clearTrack (spAnimationState* self, int trackIndex) {
spTrackEntry* current;
if (trackIndex >= self->trackCount) return;
current = self->tracks[trackIndex];
if (!current) return;
@ -181,37 +181,37 @@ void AnimationState_clearTrack (AnimationState* self, int trackIndex) {
if (self->listener) self->listener(self, trackIndex, ANIMATION_END, 0, 0);
self->tracks[trackIndex] = 0;
if (current->previous) _TrackEntry_dispose(current->previous);
_TrackEntry_disposeAll(current);
if (current->previous) _spTrackEntry_dispose(current->previous);
_spTrackEntry_disposeAll(current);
}
TrackEntry* _AnimationState_expandToIndex (AnimationState* self, int index) {
TrackEntry** newTracks;
spTrackEntry* _spAnimationState_expandToIndex (spAnimationState* self, int index) {
spTrackEntry** newTracks;
if (index < self->trackCount) return self->tracks[index];
newTracks = CALLOC(TrackEntry*, index + 1);
memcpy(newTracks, self->tracks, self->trackCount * sizeof(TrackEntry*));
newTracks = CALLOC(spTrackEntry*, index + 1);
memcpy(newTracks, self->tracks, self->trackCount * sizeof(spTrackEntry*));
self->tracks = newTracks;
self->trackCount = index + 1;
return 0;
}
void _AnimationState_setCurrent (AnimationState* self, int index, TrackEntry* entry) {
TrackEntry* current = _AnimationState_expandToIndex(self, index);
void _spAnimationState_setCurrent (spAnimationState* self, int index, spTrackEntry* entry) {
spTrackEntry* current = _spAnimationState_expandToIndex(self, index);
if (current) {
if (current->previous) {
_TrackEntry_dispose(current->previous);
_spTrackEntry_dispose(current->previous);
current->previous = 0;
}
if (current->listener) current->listener(self, index, ANIMATION_END, 0, 0);
if (self->listener) self->listener(self, index, ANIMATION_END, 0, 0);
entry->mixDuration = AnimationStateData_getMix(self->data, current->animation, entry->animation);
entry->mixDuration = spAnimationStateData_getMix(self->data, current->animation, entry->animation);
if (entry->mixDuration > 0) {
entry->mixTime = 0;
entry->previous = current;
} else
_TrackEntry_dispose(current);
_spTrackEntry_dispose(current);
}
self->tracks[index] = entry;
@ -220,41 +220,41 @@ void _AnimationState_setCurrent (AnimationState* self, int index, TrackEntry* en
if (self->listener) self->listener(self, index, ANIMATION_START, 0, 0);
}
TrackEntry* AnimationState_setAnimationByName (AnimationState* self, int trackIndex, const char* animationName, int/*bool*/loop) {
Animation* animation = SkeletonData_findAnimation(self->data->skeletonData, animationName);
return AnimationState_setAnimation(self, trackIndex, animation, loop);
spTrackEntry* spAnimationState_setAnimationByName (spAnimationState* self, int trackIndex, const char* animationName, int/*bool*/loop) {
spAnimation* animation = spSkeletonData_findAnimation(self->data->skeletonData, animationName);
return spAnimationState_setAnimation(self, trackIndex, animation, loop);
}
TrackEntry* AnimationState_setAnimation (AnimationState* self, int trackIndex, Animation* animation, int/*bool*/loop) {
TrackEntry* entry;
TrackEntry* current = _AnimationState_expandToIndex(self, trackIndex);
if (current) _TrackEntry_disposeAll(current->next);
spTrackEntry* spAnimationState_setAnimation (spAnimationState* self, int trackIndex, spAnimation* animation, int/*bool*/loop) {
spTrackEntry* entry;
spTrackEntry* current = _spAnimationState_expandToIndex(self, trackIndex);
if (current) _spTrackEntry_disposeAll(current->next);
entry = _TrackEntry_create();
entry = _spTrackEntry_create();
entry->animation = animation;
entry->loop = loop;
entry->time = 0;
entry->endTime = animation->duration;
_AnimationState_setCurrent(self, trackIndex, entry);
_spAnimationState_setCurrent(self, trackIndex, entry);
return entry;
}
TrackEntry* AnimationState_addAnimationByName (AnimationState* self, int trackIndex, const char* animationName, int/*bool*/loop,
spTrackEntry* spAnimationState_addAnimationByName (spAnimationState* self, int trackIndex, const char* animationName, int/*bool*/loop,
float delay) {
Animation* animation = SkeletonData_findAnimation(self->data->skeletonData, animationName);
return AnimationState_addAnimation(self, trackIndex, animation, loop, delay);
spAnimation* animation = spSkeletonData_findAnimation(self->data->skeletonData, animationName);
return spAnimationState_addAnimation(self, trackIndex, animation, loop, delay);
}
TrackEntry* AnimationState_addAnimation (AnimationState* self, int trackIndex, Animation* animation, int/*bool*/loop, float delay) {
TrackEntry* last;
spTrackEntry* spAnimationState_addAnimation (spAnimationState* self, int trackIndex, spAnimation* animation, int/*bool*/loop, float delay) {
spTrackEntry* last;
TrackEntry* entry = _TrackEntry_create();
spTrackEntry* entry = _spTrackEntry_create();
entry->animation = animation;
entry->loop = loop;
entry->time = 0;
entry->endTime = animation->duration;
last = _AnimationState_expandToIndex(self, trackIndex);
last = _spAnimationState_expandToIndex(self, trackIndex);
if (last) {
while (last->next)
last = last->next;
@ -265,7 +265,7 @@ TrackEntry* AnimationState_addAnimation (AnimationState* self, int trackIndex, A
if (delay <= 0) {
if (last) {
delay += last->endTime;
if (animation) delay -= AnimationStateData_getMix(self->data, last->animation, animation);
if (animation) delay -= spAnimationStateData_getMix(self->data, last->animation, animation);
} else
delay = 0;
}
@ -274,7 +274,7 @@ TrackEntry* AnimationState_addAnimation (AnimationState* self, int trackIndex, A
return entry;
}
TrackEntry* AnimationState_getCurrent (AnimationState* self, int trackIndex) {
spTrackEntry* spAnimationState_getCurrent (spAnimationState* self, int trackIndex) {
if (trackIndex >= self->trackCount) return 0;
return self->tracks[trackIndex];
}

30
spine-c/src/spine/AnimationStateData.c
View File

@ -36,12 +36,12 @@
typedef struct _ToEntry _ToEntry;
struct _ToEntry {
Animation* animation;
spAnimation* animation;
float duration;
_ToEntry* next;
};
_ToEntry* _ToEntry_create (Animation* to, float duration) {
_ToEntry* _ToEntry_create (spAnimation* to, float duration) {
_ToEntry* self = NEW(_ToEntry);
self->animation = to;
self->duration = duration;
@ -56,12 +56,12 @@ void _ToEntry_dispose (_ToEntry* self) {
typedef struct _FromEntry _FromEntry;
struct _FromEntry {
Animation* animation;
spAnimation* animation;
_ToEntry* toEntries;
_FromEntry* next;
};
_FromEntry* _FromEntry_create (Animation* from) {
_FromEntry* _FromEntry_create (spAnimation* from) {
_FromEntry* self = NEW(_FromEntry);
self->animation = from;
return self;
@ -73,13 +73,13 @@ void _FromEntry_dispose (_FromEntry* self) {
/**/
AnimationStateData* AnimationStateData_create (SkeletonData* skeletonData) {
AnimationStateData* self = NEW(AnimationStateData);
CONST_CAST(SkeletonData*, self->skeletonData) = skeletonData;
spAnimationStateData* spAnimationStateData_create (spSkeletonData* skeletonData) {
spAnimationStateData* self = NEW(spAnimationStateData);
CONST_CAST(spSkeletonData*, self->skeletonData) = skeletonData;
return self;
}
void AnimationStateData_dispose (AnimationStateData* self) {
void spAnimationStateData_dispose (spAnimationStateData* self) {
_ToEntry* toEntry;
_ToEntry* nextToEntry;
_FromEntry* nextFromEntry;
@ -100,16 +100,16 @@ void AnimationStateData_dispose (AnimationStateData* self) {
FREE(self);
}
void AnimationStateData_setMixByName (AnimationStateData* self, const char* fromName, const char* toName, float duration) {
Animation* to;
Animation* from = SkeletonData_findAnimation(self->skeletonData, fromName);
void spAnimationStateData_setMixByName (spAnimationStateData* self, const char* fromName, const char* toName, float duration) {
spAnimation* to;
spAnimation* from = spSkeletonData_findAnimation(self->skeletonData, fromName);
if (!from) return;
to = SkeletonData_findAnimation(self->skeletonData, toName);
to = spSkeletonData_findAnimation(self->skeletonData, toName);
if (!to) return;
AnimationStateData_setMix(self, from, to, duration);
spAnimationStateData_setMix(self, from, to, duration);
}
void AnimationStateData_setMix (AnimationStateData* self, Animation* from, Animation* to, float duration) {
void spAnimationStateData_setMix (spAnimationStateData* self, spAnimation* from, spAnimation* to, float duration) {
/* Find existing FromEntry. */
_ToEntry* toEntry;
_FromEntry* fromEntry = (_FromEntry*)self->entries;
@ -138,7 +138,7 @@ void AnimationStateData_setMix (AnimationStateData* self, Animation* from, Anima
fromEntry->toEntries = toEntry;
}
float AnimationStateData_getMix (AnimationStateData* self, Animation* from, Animation* to) {
float spAnimationStateData_getMix (spAnimationStateData* self, spAnimation* from, spAnimation* to) {
_FromEntry* fromEntry = (_FromEntry*)self->entries;
while (fromEntry) {
if (fromEntry->animation == from) {

64
spine-c/src/spine/Atlas.c
View File

@ -35,25 +35,25 @@
#include <ctype.h>
#include <spine/extension.h>
AtlasPage* AtlasPage_create (const char* name) {
AtlasPage* self = NEW(AtlasPage);
spAtlasPage* spAtlasPage_create (const char* name) {
spAtlasPage* self = NEW(spAtlasPage);
MALLOC_STR(self->name, name);
return self;
}
void AtlasPage_dispose (AtlasPage* self) {
_AtlasPage_disposeTexture(self);
void spAtlasPage_dispose (spAtlasPage* self) {
_spAtlasPage_disposeTexture(self);
FREE(self->name);
FREE(self);
}
/**/
AtlasRegion* AtlasRegion_create () {
return NEW(AtlasRegion) ;
spAtlasRegion* spAtlasRegion_create () {
return NEW(spAtlasRegion) ;
}
void AtlasRegion_dispose (AtlasRegion* self) {
void spAtlasRegion_dispose (spAtlasRegion* self) {
FREE(self->name);
FREE(self->splits);
FREE(self->pads);
@ -165,8 +165,8 @@ static int toInt (Str* str) {
return strtol(str->begin, (char**)&str->end, 10);
}
static Atlas* abortAtlas (Atlas* self) {
Atlas_dispose(self);
static spAtlas* abortAtlas (spAtlas* self) {
spAtlas_dispose(self);
return 0;
}
@ -174,17 +174,17 @@ static const char* formatNames[] = {"Alpha", "Intensity", "LuminanceAlpha", "RGB
static const char* textureFilterNames[] = {"Nearest", "Linear", "MipMap", "MipMapNearestNearest", "MipMapLinearNearest",
"MipMapNearestLinear", "MipMapLinearLinear"};
Atlas* Atlas_readAtlas (const char* begin, int length, const char* dir) {
spAtlas* spAtlas_readAtlas (const char* begin, int length, const char* dir) {
int count;
const char* end = begin + length;
int dirLength = strlen(dir);
int needsSlash = dirLength > 0 && dir[dirLength - 1] != '/' && dir[dirLength - 1] != '\\';
Atlas* self = NEW(Atlas);
spAtlas* self = NEW(spAtlas);
AtlasPage *page = 0;
AtlasPage *lastPage = 0;
AtlasRegion *lastRegion = 0;
spAtlasPage *page = 0;
spAtlasPage *lastPage = 0;
spAtlasRegion *lastRegion = 0;
Str str;
Str tuple[4];
readLine(begin, 0, 0);
@ -198,7 +198,7 @@ Atlas* Atlas_readAtlas (const char* begin, int length, const char* dir) {
if (needsSlash) path[dirLength] = '/';
strcpy(path + dirLength + needsSlash, name);
page = AtlasPage_create(name);
page = spAtlasPage_create(name);
FREE(name);
if (lastPage)
lastPage->next = page;
@ -207,11 +207,11 @@ Atlas* Atlas_readAtlas (const char* begin, int length, const char* dir) {
lastPage = page;
if (!readValue(end, &str)) return abortAtlas(self);
page->format = (AtlasFormat)indexOf(formatNames, 7, &str);
page->format = (spAtlasFormat)indexOf(formatNames, 7, &str);
if (!readTuple(end, tuple)) return abortAtlas(self);
page->minFilter = (AtlasFilter)indexOf(textureFilterNames, 7, tuple);
page->magFilter = (AtlasFilter)indexOf(textureFilterNames, 7, tuple + 1);
page->minFilter = (spAtlasFilter)indexOf(textureFilterNames, 7, tuple);
page->magFilter = (spAtlasFilter)indexOf(textureFilterNames, 7, tuple + 1);
if (!readValue(end, &str)) return abortAtlas(self);
if (!equals(&str, "none")) {
@ -219,10 +219,10 @@ Atlas* Atlas_readAtlas (const char* begin, int length, const char* dir) {
page->vWrap = *str.begin == 'x' ? ATLAS_CLAMPTOEDGE : (*str.begin == 'y' ? ATLAS_REPEAT : ATLAS_REPEAT);
}
_AtlasPage_createTexture(page, path);
_spAtlasPage_createTexture(page, path);
FREE(path);
} else {
AtlasRegion *region = AtlasRegion_create();
spAtlasRegion *region = spAtlasRegion_create();
if (lastRegion)
lastRegion->next = region;
else
@ -288,13 +288,13 @@ Atlas* Atlas_readAtlas (const char* begin, int length, const char* dir) {
return self;
}
Atlas* Atlas_readAtlasFile (const char* path) {
spAtlas* spAtlas_readAtlasFile (const char* path) {
int dirLength;
char *dir;
int length;
const char* data;
Atlas* atlas = 0;
spAtlas* atlas = 0;
/* Get directory from atlas path. */
const char* lastForwardSlash = strrchr(path, '/');
@ -306,35 +306,35 @@ Atlas* Atlas_readAtlasFile (const char* path) {
memcpy(dir, path, dirLength);
dir[dirLength] = '\0';
data = _Util_readFile(path, &length);
if (data) atlas = Atlas_readAtlas(data, length, dir);
data = _spUtil_readFile(path, &length);
if (data) atlas = spAtlas_readAtlas(data, length, dir);
FREE(data);
FREE(dir);
return atlas;
}
void Atlas_dispose (Atlas* self) {
AtlasRegion* region, *nextRegion;
AtlasPage* page = self->pages;
void spAtlas_dispose (spAtlas* self) {
spAtlasRegion* region, *nextRegion;
spAtlasPage* page = self->pages;
while (page) {
AtlasPage* nextPage = page->next;
AtlasPage_dispose(page);
spAtlasPage* nextPage = page->next;
spAtlasPage_dispose(page);
page = nextPage;
}
region = self->regions;
while (region) {
nextRegion = region->next;
AtlasRegion_dispose(region);
spAtlasRegion_dispose(region);
region = nextRegion;
}
FREE(self);
}
AtlasRegion* Atlas_findRegion (const Atlas* self, const char* name) {
AtlasRegion* region = self->regions;
spAtlasRegion* spAtlas_findRegion (const spAtlas* self, const char* name) {
spAtlasRegion* region = self->regions;
while (region) {
if (strcmp(region->name, name) == 0) return region;
region = region->next;

25
spine-c/src/spine/AtlasAttachmentLoader.c
View File

@ -34,19 +34,20 @@
#include <spine/AtlasAttachmentLoader.h>
#include <spine/extension.h>
Attachment* _AtlasAttachmentLoader_newAttachment (AttachmentLoader* loader, Skin* skin, AttachmentType type, const char* name) {
AtlasAttachmentLoader* self = SUB_CAST(AtlasAttachmentLoader, loader);
spAttachment* _spAtlasAttachmentLoader_newAttachment (spAttachmentLoader* loader, spSkin* skin, spAttachmentType type,
const char* name) {
spAtlasAttachmentLoader* self = SUB_CAST(spAtlasAttachmentLoader, loader);
switch (type) {
case ATTACHMENT_REGION: {
RegionAttachment* attachment;
AtlasRegion* region = Atlas_findRegion(self->atlas, name);
spRegionAttachment* attachment;
spAtlasRegion* region = spAtlas_findRegion(self->atlas, name);
if (!region) {
_AttachmentLoader_setError(loader, "Region not found: ", name);
_spAttachmentLoader_setError(loader, "Region not found: ", name);
return 0;
}
attachment = RegionAttachment_create(name);
attachment = spRegionAttachment_create(name);
attachment->rendererObject = region;
RegionAttachment_setUVs(attachment, region->u, region->v, region->u2, region->v2, region->rotate);
spRegionAttachment_setUVs(attachment, region->u, region->v, region->u2, region->v2, region->rotate);
attachment->regionOffsetX = region->offsetX;
attachment->regionOffsetY = region->offsetY;
attachment->regionWidth = region->width;
@ -56,16 +57,16 @@ Attachment* _AtlasAttachmentLoader_newAttachment (AttachmentLoader* loader, Skin
return SUPER(attachment);
}
case ATTACHMENT_BOUNDING_BOX:
return SUPER(BoundingBoxAttachment_create(name));
return SUPER(spBoundingBoxAttachment_create(name));
default:
_AttachmentLoader_setUnknownTypeError(loader, type);
_spAttachmentLoader_setUnknownTypeError(loader, type);
return 0;
}
}
AtlasAttachmentLoader* AtlasAttachmentLoader_create (Atlas* atlas) {
AtlasAttachmentLoader* self = NEW(AtlasAttachmentLoader);
_AttachmentLoader_init(SUPER(self), _AttachmentLoader_deinit, _AtlasAttachmentLoader_newAttachment);
spAtlasAttachmentLoader* spAtlasAttachmentLoader_create (spAtlas* atlas) {
spAtlasAttachmentLoader* self = NEW(spAtlasAttachmentLoader);
_spAttachmentLoader_init(SUPER(self), _spAttachmentLoader_deinit, _spAtlasAttachmentLoader_newAttachment);
self->atlas = atlas;
return self;
}

20
spine-c/src/spine/Attachment.c
View File

@ -35,26 +35,26 @@
#include <spine/extension.h>
#include <spine/Slot.h>
typedef struct _AttachmentVtable {
void (*dispose) (Attachment* self);
} _AttachmentVtable;
typedef struct _spAttachmentVtable {
void (*dispose) (spAttachment* self);
} _spAttachmentVtable;
void _Attachment_init (Attachment* self, const char* name, AttachmentType type, /**/
void (*dispose) (Attachment* self)) {
void _spAttachment_init (spAttachment* self, const char* name, spAttachmentType type, /**/
void (*dispose) (spAttachment* self)) {
CONST_CAST(_AttachmentVtable*, self->vtable) = NEW(_AttachmentVtable);
VTABLE(Attachment, self) ->dispose = dispose;
CONST_CAST(_spAttachmentVtable*, self->vtable) = NEW(_spAttachmentVtable);
VTABLE(spAttachment, self) ->dispose = dispose;
MALLOC_STR(self->name, name);
self->type = type;
}
void _Attachment_deinit (Attachment* self) {
void _spAttachment_deinit (spAttachment* self) {
FREE(self->vtable);
FREE(self->name);
}
void Attachment_dispose (Attachment* self) {
VTABLE(Attachment, self) ->dispose(self);
void spAttachment_dispose (spAttachment* self) {
VTABLE(spAttachment, self) ->dispose(self);
FREE(self);
}

36
spine-c/src/spine/AttachmentLoader.c
View File

@ -35,47 +35,47 @@
#include <stdio.h>
#include <spine/extension.h>
typedef struct _AttachmentLoaderVtable {
Attachment* (*newAttachment) (AttachmentLoader* self, Skin* skin, AttachmentType type, const char* name);
void (*dispose) (AttachmentLoader* self);
} _AttachmentLoaderVtable;
typedef struct _spAttachmentLoaderVtable {
spAttachment* (*newAttachment) (spAttachmentLoader* self, spSkin* skin, spAttachmentType type, const char* name);
void (*dispose) (spAttachmentLoader* self);
} _spAttachmentLoaderVtable;
void _AttachmentLoader_init (AttachmentLoader* self, /**/
void (*dispose) (AttachmentLoader* self), /**/
Attachment* (*newAttachment) (AttachmentLoader* self, Skin* skin, AttachmentType type, const char* name)) {
CONST_CAST(_AttachmentLoaderVtable*, self->vtable) = NEW(_AttachmentLoaderVtable);
VTABLE(AttachmentLoader, self) ->dispose = dispose;
VTABLE(AttachmentLoader, self) ->newAttachment = newAttachment;
void _spAttachmentLoader_init (spAttachmentLoader* self, /**/
void (*dispose) (spAttachmentLoader* self), /**/
spAttachment* (*newAttachment) (spAttachmentLoader* self, spSkin* skin, spAttachmentType type, const char* name)) {
CONST_CAST(_spAttachmentLoaderVtable*, self->vtable) = NEW(_spAttachmentLoaderVtable);
VTABLE(spAttachmentLoader, self)->dispose = dispose;
VTABLE(spAttachmentLoader, self)->newAttachment = newAttachment;
}
void _AttachmentLoader_deinit (AttachmentLoader* self) {
void _spAttachmentLoader_deinit (spAttachmentLoader* self) {
FREE(self->vtable);
FREE(self->error1);
FREE(self->error2);
}
void AttachmentLoader_dispose (AttachmentLoader* self) {
VTABLE(AttachmentLoader, self) ->dispose(self);
void spAttachmentLoader_dispose (spAttachmentLoader* self) {
VTABLE(spAttachmentLoader, self)->dispose(self);
FREE(self);
}
Attachment* AttachmentLoader_newAttachment (AttachmentLoader* self, Skin* skin, AttachmentType type, const char* name) {
spAttachment* spAttachmentLoader_newAttachment (spAttachmentLoader* self, spSkin* skin, spAttachmentType type, const char* name) {
FREE(self->error1);
FREE(self->error2);
self->error1 = 0;
self->error2 = 0;
return VTABLE(AttachmentLoader, self) ->newAttachment(self, skin, type, name);
return VTABLE(spAttachmentLoader, self)->newAttachment(self, skin, type, name);
}
void _AttachmentLoader_setError (AttachmentLoader* self, const char* error1, const char* error2) {
void _spAttachmentLoader_setError (spAttachmentLoader* self, const char* error1, const char* error2) {
FREE(self->error1);
FREE(self->error2);
MALLOC_STR(self->error1, error1);
MALLOC_STR(self->error2, error2);
}
void _AttachmentLoader_setUnknownTypeError (AttachmentLoader* self, AttachmentType type) {
void _spAttachmentLoader_setUnknownTypeError (spAttachmentLoader* self, spAttachmentType type) {
char buffer[16];
sprintf(buffer, "%d", type);
_AttachmentLoader_setError(self, "Unknown attachment type: ", buffer);
_spAttachmentLoader_setError(self, "Unknown attachment type: ", buffer);
}

18
spine-c/src/spine/Bone.c
View File

@ -36,23 +36,23 @@
static int yDown;
void Bone_setYDown (int value) {
void spBone_setYDown (int value) {
yDown = value;
}
Bone* Bone_create (BoneData* data, Bone* parent) {
Bone* self = NEW(Bone);
CONST_CAST(BoneData*, self->data) = data;
CONST_CAST(Bone*, self->parent) = parent;
Bone_setToSetupPose(self);
spBone* spBone_create (spBoneData* data, spBone* parent) {
spBone* self = NEW(spBone);
CONST_CAST(spBoneData*, self->data) = data;
CONST_CAST(spBone*, self->parent) = parent;
spBone_setToSetupPose(self);
return self;
}
void Bone_dispose (Bone* self) {
void spBone_dispose (spBone* self) {
FREE(self);
}
void Bone_setToSetupPose (Bone* self) {
void spBone_setToSetupPose (spBone* self) {
self->x = self->data->x;
self->y = self->data->y;
self->rotation = self->data->rotation;
@ -60,7 +60,7 @@ void Bone_setToSetupPose (Bone* self) {
self->scaleY = self->data->scaleY;
}
void Bone_updateWorldTransform (Bone* self, int flipX, int flipY) {
void spBone_updateWorldTransform (spBone* self, int flipX, int flipY) {
float radians, cosine, sine;
if (self->parent) {
CONST_CAST(float, self->worldX) = self->x * self->parent->m00 + self->y * self->parent->m01 + self->parent->worldX;

8
spine-c/src/spine/BoneData.c
View File

@ -34,10 +34,10 @@
#include <spine/BoneData.h>
#include <spine/extension.h>
BoneData* BoneData_create (const char* name, BoneData* parent) {
BoneData* self = NEW(BoneData);
spBoneData* spBoneData_create (const char* name, spBoneData* parent) {
spBoneData* self = NEW(spBoneData);
MALLOC_STR(self->name, name);
CONST_CAST(BoneData*, self->parent) = parent;
CONST_CAST(spBoneData*, self->parent) = parent;
self->scaleX = 1;
self->scaleY = 1;
self->inheritScale = 1;
@ -45,7 +45,7 @@ BoneData* BoneData_create (const char* name, BoneData* parent) {
return self;
}
void BoneData_dispose (BoneData* self) {
void spBoneData_dispose (spBoneData* self) {
FREE(self->name);
FREE(self);
}

8
spine-c/src/spine/BoundingBoxAttachment.c
View File

@ -34,13 +34,13 @@
#include <spine/BoundingBoxAttachment.h>
#include <spine/extension.h>
BoundingBoxAttachment* BoundingBoxAttachment_create (const char* name) {
BoundingBoxAttachment* self = NEW(BoundingBoxAttachment);
_Attachment_init(SUPER(self), name, ATTACHMENT_BOUNDING_BOX, _Attachment_deinit);
spBoundingBoxAttachment* spBoundingBoxAttachment_create (const char* name) {
spBoundingBoxAttachment* self = NEW(spBoundingBoxAttachment);
_spAttachment_init(SUPER(self), name, ATTACHMENT_BOUNDING_BOX, _spAttachment_deinit);
return self;
}
void BoundingBoxAttachment_computeWorldVertices (BoundingBoxAttachment* self, float x, float y, Bone* bone, float* worldVertices) {
void spBoundingBoxAttachment_computeWorldVertices (spBoundingBoxAttachment* self, float x, float y, spBone* bone, float* worldVertices) {
int i;
float px, py;
float* vertices = self->vertices;

8
spine-c/src/spine/Event.c
View File

@ -34,13 +34,13 @@
#include <spine/Event.h>
#include <spine/extension.h>
Event* Event_create (EventData* data) {
Event* self = NEW(Event);
CONST_CAST(EventData*, self->data) = data;
spEvent* spEvent_create (spEventData* data) {
spEvent* self = NEW(spEvent);
CONST_CAST(spEventData*, self->data) = data;
return self;
}
void Event_dispose (Event* self) {
void spEvent_dispose (spEvent* self) {
FREE(self->stringValue);
FREE(self);
}

6
spine-c/src/spine/EventData.c
View File

@ -34,13 +34,13 @@
#include <spine/EventData.h>
#include <spine/extension.h>
EventData* EventData_create (const char* name) {
EventData* self = NEW(EventData);
spEventData* spEventData_create (const char* name) {
spEventData* self = NEW(spEventData);
MALLOC_STR(self->name, name);
return self;
}
void EventData_dispose (EventData* self) {
void spEventData_dispose (spEventData* self) {
FREE(self->stringValue);
FREE(self->name);
FREE(self);

12
spine-c/src/spine/RegionAttachment.c
View File

@ -34,15 +34,15 @@
#include <spine/RegionAttachment.h>
#include <spine/extension.h>
RegionAttachment* RegionAttachment_create (const char* name) {
RegionAttachment* self = NEW(RegionAttachment);
spRegionAttachment* spRegionAttachment_create (const char* name) {
spRegionAttachment* self = NEW(spRegionAttachment);
self->scaleX = 1;
self->scaleY = 1;
_Attachment_init(SUPER(self), name, ATTACHMENT_REGION, _Attachment_deinit);
_spAttachment_init(SUPER(self), name, ATTACHMENT_REGION, _spAttachment_deinit);
return self;
}
void RegionAttachment_setUVs (RegionAttachment* self, float u, float v, float u2, float v2, int/*bool*/rotate) {
void spRegionAttachment_setUVs (spRegionAttachment* self, float u, float v, float u2, float v2, int/*bool*/rotate) {
if (rotate) {
self->uvs[VERTEX_X2] = u;
self->uvs[VERTEX_Y2] = v2;
@ -64,7 +64,7 @@ void RegionAttachment_setUVs (RegionAttachment* self, float u, float v, float u2
}
}
void RegionAttachment_updateOffset (RegionAttachment* self) {
void spRegionAttachment_updateOffset (spRegionAttachment* self) {
float regionScaleX = self->width / self->regionOriginalWidth * self->scaleX;
float regionScaleY = self->height / self->regionOriginalHeight * self->scaleY;
float localX = -self->width / 2 * self->scaleX + self->regionOffsetX * regionScaleX;
@ -97,7 +97,7 @@ void RegionAttachment_updateOffset (RegionAttachment* self) {
self->offset[VERTEX_Y4] = localYCos + localX2Sin;
}
void RegionAttachment_computeWorldVertices (RegionAttachment* self, float x, float y, Bone* bone, float* vertices) {
void spRegionAttachment_computeWorldVertices (spRegionAttachment* self, float x, float y, spBone* bone, float* vertices) {
float* offset = self->offset;
x += bone->worldX;
y += bone->worldY;

100
spine-c/src/spine/Skeleton.c
View File

@ -35,18 +35,18 @@
#include <string.h>
#include <spine/extension.h>
Skeleton* Skeleton_create (SkeletonData* data) {
spSkeleton* spSkeleton_create (spSkeletonData* data) {
int i, ii;
Skeleton* self = NEW(Skeleton);
CONST_CAST(SkeletonData*, self->data) = data;
spSkeleton* self = NEW(spSkeleton);
CONST_CAST(spSkeletonData*, self->data) = data;
self->boneCount = self->data->boneCount;
self->bones = MALLOC(Bone*, self->boneCount);
self->bones = MALLOC(spBone*, self->boneCount);
for (i = 0; i < self->boneCount; ++i) {
BoneData* boneData = self->data->bones[i];
Bone* parent = 0;
spBoneData* boneData = self->data->bones[i];
spBone* parent = 0;
if (boneData->parent) {
/* Find parent bone. */
for (ii = 0; ii < self->boneCount; ++ii) {
@ -56,28 +56,28 @@ Skeleton* Skeleton_create (SkeletonData* data) {
}
}
}
self->bones[i] = Bone_create(boneData, parent);
self->bones[i] = spBone_create(boneData, parent);
}
CONST_CAST(Bone*, self->root) = self->bones[0];
CONST_CAST(spBone*, self->root) = self->bones[0];
self->slotCount = data->slotCount;
self->slots = MALLOC(Slot*, self->slotCount);
self->slots = MALLOC(spSlot*, self->slotCount);
for (i = 0; i < self->slotCount; ++i) {
SlotData *slotData = data->slots[i];
spSlotData *slotData = data->slots[i];
/* Find bone for the slotData's boneData. */
Bone* bone = 0;
spBone* bone = 0;
for (ii = 0; ii < self->boneCount; ++ii) {
if (data->bones[ii] == slotData->boneData) {
bone = self->bones[ii];
break;
}
}
self->slots[i] = Slot_create(slotData, self, bone);
self->slots[i] = spSlot_create(slotData, self, bone);
}
self->drawOrder = MALLOC(Slot*, self->slotCount);
memcpy(self->drawOrder, self->slots, sizeof(Slot*) * self->slotCount);
self->drawOrder = MALLOC(spSlot*, self->slotCount);
memcpy(self->drawOrder, self->slots, sizeof(spSlot*) * self->slotCount);
self->r = 1;
self->g = 1;
@ -87,118 +87,118 @@ Skeleton* Skeleton_create (SkeletonData* data) {
return self;
}
void Skeleton_dispose (Skeleton* self) {
void spSkeleton_dispose (spSkeleton* self) {
int i;
for (i = 0; i < self->boneCount; ++i)
Bone_dispose(self->bones[i]);
spBone_dispose(self->bones[i]);
FREE(self->bones);
for (i = 0; i < self->slotCount; ++i)
Slot_dispose(self->slots[i]);
spSlot_dispose(self->slots[i]);
FREE(self->slots);
FREE(self->drawOrder);
FREE(self);
}
void Skeleton_updateWorldTransform (const Skeleton* self) {
void spSkeleton_updateWorldTransform (const spSkeleton* self) {
int i;
for (i = 0; i < self->boneCount; ++i)
Bone_updateWorldTransform(self->bones[i], self->flipX, self->flipY);
spBone_updateWorldTransform(self->bones[i], self->flipX, self->flipY);
}
void Skeleton_setToSetupPose (const Skeleton* self) {
Skeleton_setBonesToSetupPose(self);
Skeleton_setSlotsToSetupPose(self);
void spSkeleton_setToSetupPose (const spSkeleton* self) {
spSkeleton_setBonesToSetupPose(self);
spSkeleton_setSlotsToSetupPose(self);
}
void Skeleton_setBonesToSetupPose (const Skeleton* self) {
void spSkeleton_setBonesToSetupPose (const spSkeleton* self) {
int i;
for (i = 0; i < self->boneCount; ++i)
Bone_setToSetupPose(self->bones[i]);
spBone_setToSetupPose(self->bones[i]);
}
void Skeleton_setSlotsToSetupPose (const Skeleton* self) {
void spSkeleton_setSlotsToSetupPose (const spSkeleton* self) {
int i;
memcpy(self->drawOrder, self->slots, self->slotCount * sizeof(int));
for (i = 0; i < self->slotCount; ++i)
Slot_setToSetupPose(self->slots[i]);
spSlot_setToSetupPose(self->slots[i]);
}
Bone* Skeleton_findBone (const Skeleton* self, const char* boneName) {
spBone* spSkeleton_findBone (const spSkeleton* self, const char* boneName) {
int i;
for (i = 0; i < self->boneCount; ++i)
if (strcmp(self->data->bones[i]->name, boneName) == 0) return self->bones[i];
return 0;
}
int Skeleton_findBoneIndex (const Skeleton* self, const char* boneName) {
int spSkeleton_findBoneIndex (const spSkeleton* self, const char* boneName) {
int i;
for (i = 0; i < self->boneCount; ++i)
if (strcmp(self->data->bones[i]->name, boneName) == 0) return i;
return -1;
}
Slot* Skeleton_findSlot (const Skeleton* self, const char* slotName) {
spSlot* spSkeleton_findSlot (const spSkeleton* self, const char* slotName) {
int i;
for (i = 0; i < self->slotCount; ++i)
if (strcmp(self->data->slots[i]->name, slotName) == 0) return self->slots[i];
return 0;
}
int Skeleton_findSlotIndex (const Skeleton* self, const char* slotName) {
int spSkeleton_findSlotIndex (const spSkeleton* self, const char* slotName) {
int i;
for (i = 0; i < self->slotCount; ++i)
if (strcmp(self->data->slots[i]->name, slotName) == 0) return i;
return -1;
}
int Skeleton_setSkinByName (Skeleton* self, const char* skinName) {
Skin *skin;
int spSkeleton_setSkinByName (spSkeleton* self, const char* skinName) {
spSkin *skin;
if (!skinName) {
Skeleton_setSkin(self, 0);
spSkeleton_setSkin(self, 0);
return 1;
}
skin = SkeletonData_findSkin(self->data, skinName);
skin = spSkeletonData_findSkin(self->data, skinName);
if (!skin) return 0;
Skeleton_setSkin(self, skin);
spSkeleton_setSkin(self, skin);
return 1;
}
void Skeleton_setSkin (Skeleton* self, Skin* newSkin) {
if (self->skin && newSkin) Skin_attachAll(newSkin, self, self->skin);
CONST_CAST(Skin*, self->skin) = newSkin;
void spSkeleton_setSkin (spSkeleton* self, spSkin* newSkin) {
if (self->skin && newSkin) spSkin_attachAll(newSkin, self, self->skin);
CONST_CAST(spSkin*, self->skin) = newSkin;
}
Attachment* Skeleton_getAttachmentForSlotName (const Skeleton* self, const char* slotName, const char* attachmentName) {
int slotIndex = SkeletonData_findSlotIndex(self->data, slotName);
return Skeleton_getAttachmentForSlotIndex(self, slotIndex, attachmentName);
spAttachment* spSkeleton_getAttachmentForSlotName (const spSkeleton* self, const char* slotName, const char* attachmentName) {
int slotIndex = spSkeletonData_findSlotIndex(self->data, slotName);
return spSkeleton_getAttachmentForSlotIndex(self, slotIndex, attachmentName);
}
Attachment* Skeleton_getAttachmentForSlotIndex (const Skeleton* self, int slotIndex, const char* attachmentName) {
spAttachment* spSkeleton_getAttachmentForSlotIndex (const spSkeleton* self, int slotIndex, const char* attachmentName) {
if (slotIndex == -1) return 0;
if (self->skin) {
Attachment *attachment = Skin_getAttachment(self->skin, slotIndex, attachmentName);
spAttachment *attachment = spSkin_getAttachment(self->skin, slotIndex, attachmentName);
if (attachment) return attachment;
}
if (self->data->defaultSkin) {
Attachment *attachment = Skin_getAttachment(self->data->defaultSkin, slotIndex, attachmentName);
spAttachment *attachment = spSkin_getAttachment(self->data->defaultSkin, slotIndex, attachmentName);
if (attachment) return attachment;
}
return 0;
}
int Skeleton_setAttachment (Skeleton* self, const char* slotName, const char* attachmentName) {
int spSkeleton_setAttachment (spSkeleton* self, const char* slotName, const char* attachmentName) {
int i;
for (i = 0; i < self->slotCount; ++i) {
Slot *slot = self->slots[i];
spSlot *slot = self->slots[i];
if (strcmp(slot->data->name, slotName) == 0) {
if (!attachmentName)
Slot_setAttachment(slot, 0);
spSlot_setAttachment(slot, 0);
else {
Attachment* attachment = Skeleton_getAttachmentForSlotIndex(self, i, attachmentName);
spAttachment* attachment = spSkeleton_getAttachmentForSlotIndex(self, i, attachmentName);
if (!attachment) return 0;
Slot_setAttachment(slot, attachment);
spSlot_setAttachment(slot, attachment);
}
return 1;
}
@ -206,6 +206,6 @@ int Skeleton_setAttachment (Skeleton* self, const char* slotName, const char* at
return 0;
}
void Skeleton_update (Skeleton* self, float deltaTime) {
void spSkeleton_update (spSkeleton* self, float deltaTime) {
self->time += deltaTime;
}

66
spine-c/src/spine/SkeletonBounds.c
View File

@ -35,19 +35,19 @@
#include <limits.h>
#include <spine/extension.h>
BoundingPolygon* BoundingPolygon_create (int capacity) {
BoundingPolygon* self = NEW(BoundingPolygon);
spBoundingPolygon* spBoundingPolygon_create (int capacity) {
spBoundingPolygon* self = NEW(spBoundingPolygon);
self->capacity = capacity;
CONST_CAST(float*, self->vertices) = MALLOC(float, capacity);
return self;
}
void BoundingPolygon_dispose (BoundingPolygon* self) {
void spBoundingPolygon_dispose (spBoundingPolygon* self) {
FREE(self->vertices);
FREE(self);
}
int/*bool*/BoundingPolygon_containsPoint (BoundingPolygon* self, float x, float y) {
int/*bool*/spBoundingPolygon_containsPoint (spBoundingPolygon* self, float x, float y) {
int prevIndex = self->count - 2;
int inside = 0;
int i;
@ -63,7 +63,7 @@ int/*bool*/BoundingPolygon_containsPoint (BoundingPolygon* self, float x, float
return inside;
}
int/*bool*/BoundingPolygon_intersectsSegment (BoundingPolygon* self, float x1, float y1, float x2, float y2) {
int/*bool*/spBoundingPolygon_intersectsSegment (spBoundingPolygon* self, float x1, float y1, float x2, float y2) {
float width12 = x1 - x2, height12 = y1 - y2;
float det1 = x1 * y2 - y1 * x2;
float x3 = self->vertices[self->count - 2], y3 = self->vertices[self->count - 1];
@ -87,34 +87,34 @@ int/*bool*/BoundingPolygon_intersectsSegment (BoundingPolygon* self, float x1, f
/**/
typedef struct {
SkeletonBounds super;
spSkeletonBounds super;
int capacity;
} _SkeletonBounds;
} _spSkeletonBounds;
SkeletonBounds* SkeletonBounds_create () {
return SUPER(NEW(_SkeletonBounds));
spSkeletonBounds* spSkeletonBounds_create () {
return SUPER(NEW(_spSkeletonBounds));
}
void SkeletonBounds_dispose (SkeletonBounds* self) {
void spSkeletonBounds_dispose (spSkeletonBounds* self) {
int i;
for (i = 0; i < SUB_CAST(_SkeletonBounds, self)->capacity; ++i)
if (self->polygons[i]) BoundingPolygon_dispose(self->polygons[i]);
for (i = 0; i < SUB_CAST(_spSkeletonBounds, self)->capacity; ++i)
if (self->polygons[i]) spBoundingPolygon_dispose(self->polygons[i]);
FREE(self->polygons);
FREE(self->boundingBoxes);
FREE(self);
}
void SkeletonBounds_update (SkeletonBounds* self, Skeleton* skeleton, int/*bool*/updateAabb) {
void spSkeletonBounds_update (spSkeletonBounds* self, spSkeleton* skeleton, int/*bool*/updateAabb) {
int i;
_SkeletonBounds* internal = SUB_CAST(_SkeletonBounds, self);
_spSkeletonBounds* internal = SUB_CAST(_spSkeletonBounds, self);
if (internal->capacity < skeleton->slotCount) {
BoundingPolygon** newPolygons;
spBoundingPolygon** newPolygons;
FREE(self->boundingBoxes);
self->boundingBoxes = MALLOC(BoundingBoxAttachment*, skeleton->slotCount);
self->boundingBoxes = MALLOC(spBoundingBoxAttachment*, skeleton->slotCount);
newPolygons = CALLOC(BoundingPolygon*, skeleton->slotCount);
newPolygons = CALLOC(spBoundingPolygon*, skeleton->slotCount);
memcpy(newPolygons, self->polygons, internal->capacity);
FREE(self->polygons);
self->polygons = newPolygons;
@ -129,22 +129,22 @@ void SkeletonBounds_update (SkeletonBounds* self, Skeleton* skeleton, int/*bool*
self->count = 0;
for (i = 0; i < skeleton->slotCount; ++i) {
BoundingPolygon* polygon;
BoundingBoxAttachment* boundingBox;
spBoundingPolygon* polygon;
spBoundingBoxAttachment* boundingBox;
Slot* slot = skeleton->slots[i];
Attachment* attachment = slot->attachment;
spSlot* slot = skeleton->slots[i];
spAttachment* attachment = slot->attachment;
if (!attachment || attachment->type != ATTACHMENT_BOUNDING_BOX) continue;
boundingBox = (BoundingBoxAttachment*)attachment;
boundingBox = (spBoundingBoxAttachment*)attachment;
self->boundingBoxes[self->count] = boundingBox;
polygon = self->polygons[self->count];
if (!polygon || polygon->capacity < boundingBox->verticesCount) {
if (polygon) BoundingPolygon_dispose(polygon);
self->polygons[self->count] = polygon = BoundingPolygon_create(boundingBox->verticesCount);
if (polygon) spBoundingPolygon_dispose(polygon);
self->polygons[self->count] = polygon = spBoundingPolygon_create(boundingBox->verticesCount);
}
polygon->count = boundingBox->verticesCount;
BoundingBoxAttachment_computeWorldVertices(boundingBox, skeleton->x, skeleton->y, slot->bone, polygon->vertices);
spBoundingBoxAttachment_computeWorldVertices(boundingBox, skeleton->x, skeleton->y, slot->bone, polygon->vertices);
if (updateAabb) {
int ii = 0;
@ -162,11 +162,11 @@ void SkeletonBounds_update (SkeletonBounds* self, Skeleton* skeleton, int/*bool*
}
}
int/*bool*/SkeletonBounds_aabbContainsPoint (SkeletonBounds* self, float x, float y) {
int/*bool*/spSkeletonBounds_aabbContainsPoint (spSkeletonBounds* self, float x, float y) {
return x >= self->minX && x <= self->maxX && y >= self->minY && y <= self->maxY;
}
int/*bool*/SkeletonBounds_aabbIntersectsSegment (SkeletonBounds* self, float x1, float y1, float x2, float y2) {
int/*bool*/spSkeletonBounds_aabbIntersectsSegment (spSkeletonBounds* self, float x1, float y1, float x2, float y2) {
float m, x, y;
if ((x1 <= self->minX && x2 <= self->minX) || (y1 <= self->minY && y2 <= self->minY) || (x1 >= self->maxX && x2 >= self->maxX)
|| (y1 >= self->maxY && y2 >= self->maxY)) return 0;
@ -182,25 +182,25 @@ int/*bool*/SkeletonBounds_aabbIntersectsSegment (SkeletonBounds* self, float x1,
return 0;
}
int/*bool*/SkeletonBounds_aabbIntersectsSkeleton (SkeletonBounds* self, SkeletonBounds* bounds) {
int/*bool*/spSkeletonBounds_aabbIntersectsSkeleton (spSkeletonBounds* self, spSkeletonBounds* bounds) {
return self->minX < bounds->maxX && self->maxX > bounds->minX && self->minY < bounds->maxY && self->maxY > bounds->minY;
}
BoundingBoxAttachment* SkeletonBounds_containsPoint (SkeletonBounds* self, float x, float y) {
spBoundingBoxAttachment* spSkeletonBounds_containsPoint (spSkeletonBounds* self, float x, float y) {
int i;
for (i = 0; i < self->count; ++i)
if (BoundingPolygon_containsPoint(self->polygons[i], x, y)) return self->boundingBoxes[i];
if (spBoundingPolygon_containsPoint(self->polygons[i], x, y)) return self->boundingBoxes[i];
return 0;
}
BoundingBoxAttachment* SkeletonBounds_intersectsSegment (SkeletonBounds* self, float x1, float y1, float x2, float y2) {
spBoundingBoxAttachment* spSkeletonBounds_intersectsSegment (spSkeletonBounds* self, float x1, float y1, float x2, float y2) {
int i;
for (i = 0; i < self->count; ++i)
if (BoundingPolygon_intersectsSegment(self->polygons[i], x1, y1, x2, y2)) return self->boundingBoxes[i];
if (spBoundingPolygon_intersectsSegment(self->polygons[i], x1, y1, x2, y2)) return self->boundingBoxes[i];
return 0;
}
BoundingPolygon* SkeletonBounds_getPolygon (SkeletonBounds* self, BoundingBoxAttachment* boundingBox) {
spBoundingPolygon* spSkeletonBounds_getPolygon (spSkeletonBounds* self, spBoundingBoxAttachment* boundingBox) {
int i;
for (i = 0; i < self->count; ++i)
if (self->boundingBoxes[i] == boundingBox) return self->polygons[i];

28
spine-c/src/spine/SkeletonData.c
View File

@ -35,74 +35,74 @@
#include <string.h>
#include <spine/extension.h>
SkeletonData* SkeletonData_create () {
return NEW(SkeletonData);
spSkeletonData* spSkeletonData_create () {
return NEW(spSkeletonData);
}
void SkeletonData_dispose (SkeletonData* self) {
void spSkeletonData_dispose (spSkeletonData* self) {
int i;
for (i = 0; i < self->boneCount; ++i)
BoneData_dispose(self->bones[i]);
spBoneData_dispose(self->bones[i]);
FREE(self->bones);
for (i = 0; i < self->slotCount; ++i)
SlotData_dispose(self->slots[i]);
spSlotData_dispose(self->slots[i]);
FREE(self->slots);
for (i = 0; i < self->skinCount; ++i)
Skin_dispose(self->skins[i]);
spSkin_dispose(self->skins[i]);
FREE(self->skins);
for (i = 0; i < self->animationCount; ++i)
Animation_dispose(self->animations[i]);
spAnimation_dispose(self->animations[i]);
FREE(self->animations);
FREE(self);
}
BoneData* SkeletonData_findBone (const SkeletonData* self, const char* boneName) {
spBoneData* spSkeletonData_findBone (const spSkeletonData* self, const char* boneName) {
int i;
for (i = 0; i < self->boneCount; ++i)
if (strcmp(self->bones[i]->name, boneName) == 0) return self->bones[i];
return 0;
}
int SkeletonData_findBoneIndex (const SkeletonData* self, const char* boneName) {
int spSkeletonData_findBoneIndex (const spSkeletonData* self, const char* boneName) {
int i;
for (i = 0; i < self->boneCount; ++i)
if (strcmp(self->bones[i]->name, boneName) == 0) return i;
return 0;
}
SlotData* SkeletonData_findSlot (const SkeletonData* self, const char* slotName) {
spSlotData* spSkeletonData_findSlot (const spSkeletonData* self, const char* slotName) {
int i;
for (i = 0; i < self->slotCount; ++i)
if (strcmp(self->slots[i]->name, slotName) == 0) return self->slots[i];
return 0;
}
int SkeletonData_findSlotIndex (const SkeletonData* self, const char* slotName) {
int spSkeletonData_findSlotIndex (const spSkeletonData* self, const char* slotName) {
int i;
for (i = 0; i < self->slotCount; ++i)
if (strcmp(self->slots[i]->name, slotName) == 0) return i;
return 0;
}
Skin* SkeletonData_findSkin (const SkeletonData* self, const char* skinName) {
spSkin* spSkeletonData_findSkin (const spSkeletonData* self, const char* skinName) {
int i;
for (i = 0; i < self->skinCount; ++i)
if (strcmp(self->skins[i]->name, skinName) == 0) return self->skins[i];
return 0;
}
EventData* SkeletonData_findEvent (const SkeletonData* self, const char* eventName) {
spEventData* spSkeletonData_findEvent (const spSkeletonData* self, const char* eventName) {
int i;
for (i = 0; i < self->eventCount; ++i)
if (strcmp(self->events[i]->name, eventName) == 0) return self->events[i];
return 0;
}
Animation* SkeletonData_findAnimation (const SkeletonData* self, const char* animationName) {
spAnimation* spSkeletonData_findAnimation (const spSkeletonData* self, const char* animationName) {
int i;
for (i = 0; i < self->animationCount; ++i)
if (strcmp(self->animations[i]->name, animationName) == 0) return self->animations[i];

190
spine-c/src/spine/SkeletonJson.c
View File

@ -39,31 +39,31 @@
#include <spine/AtlasAttachmentLoader.h>
typedef struct {
SkeletonJson super;
spSkeletonJson super;
int ownsLoader;
} _SkeletonJson;
} _spSkeletonJson;
SkeletonJson* SkeletonJson_createWithLoader (AttachmentLoader* attachmentLoader) {
SkeletonJson* self = SUPER(NEW(_SkeletonJson));
spSkeletonJson* spSkeletonJson_createWithLoader (spAttachmentLoader* attachmentLoader) {
spSkeletonJson* self = SUPER(NEW(_spSkeletonJson));
self->scale = 1;
self->attachmentLoader = attachmentLoader;
return self;
}
SkeletonJson* SkeletonJson_create (Atlas* atlas) {
AtlasAttachmentLoader* attachmentLoader = AtlasAttachmentLoader_create(atlas);
SkeletonJson* self = SkeletonJson_createWithLoader(SUPER(attachmentLoader));
SUB_CAST(_SkeletonJson, self)->ownsLoader = 1;
spSkeletonJson* spSkeletonJson_create (spAtlas* atlas) {
spAtlasAttachmentLoader* attachmentLoader = spAtlasAttachmentLoader_create(atlas);
spSkeletonJson* self = spSkeletonJson_createWithLoader(SUPER(attachmentLoader));
SUB_CAST(_spSkeletonJson, self)->ownsLoader = 1;
return self;
}
void SkeletonJson_dispose (SkeletonJson* self) {
if (SUB_CAST(_SkeletonJson, self)->ownsLoader) AttachmentLoader_dispose(self->attachmentLoader);
void spSkeletonJson_dispose (spSkeletonJson* self) {
if (SUB_CAST(_spSkeletonJson, self)->ownsLoader) spAttachmentLoader_dispose(self->attachmentLoader);
FREE(self->error);
FREE(self);
}
void _SkeletonJson_setError (SkeletonJson* self, Json* root, const char* value1, const char* value2) {
void _spSkeletonJson_setError (spSkeletonJson* self, Json* root, const char* value1, const char* value2) {
char message[256];
int length;
FREE(self->error);
@ -90,24 +90,24 @@ static float toColor (const char* value, int index) {
return color / (float)255;
}
static void readCurve (CurveTimeline* timeline, int frameIndex, Json* frame) {
static void readCurve (spCurveTimeline* timeline, int frameIndex, Json* frame) {
Json* curve = Json_getItem(frame, "curve");
if (!curve) return;
if (curve->type == Json_String && strcmp(curve->valueString, "stepped") == 0)
CurveTimeline_setStepped(timeline, frameIndex);
spCurveTimeline_setStepped(timeline, frameIndex);
else if (curve->type == Json_Array) {
Json* child0 = curve->child;
Json* child1 = child0->next;
Json* child2 = child1->next;
Json* child3 = child2->next;
CurveTimeline_setCurve(timeline, frameIndex, child0->valueFloat, child1->valueFloat, child2->valueFloat,
spCurveTimeline_setCurve(timeline, frameIndex, child0->valueFloat, child1->valueFloat, child2->valueFloat,
child3->valueFloat);
}
}
static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, SkeletonData *skeletonData) {
static spAnimation* _spSkeletonJson_readAnimation (spSkeletonJson* self, Json* root, spSkeletonData *skeletonData) {
int i;
Animation* animation;
spAnimation* animation;
Json* bones = Json_getItem(root, "bones");
Json* slots = Json_getItem(root, "slots");
@ -123,7 +123,7 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
if (events) ++timelineCount;
if (drawOrder) ++timelineCount;
animation = Animation_create(root->name, timelineCount);
animation = spAnimation_create(root->name, timelineCount);
animation->timelineCount = 0;
skeletonData->animations[skeletonData->animationCount] = animation;
++skeletonData->animationCount;
@ -131,10 +131,10 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
for (boneMap = bones ? bones->child : 0; boneMap; boneMap = boneMap->next) {
Json *timelineArray;
int boneIndex = SkeletonData_findBoneIndex(skeletonData, boneMap->name);
int boneIndex = spSkeletonData_findBoneIndex(skeletonData, boneMap->name);
if (boneIndex == -1) {
Animation_dispose(animation);
_SkeletonJson_setError(self, root, "Bone not found: ", boneMap->name);
spAnimation_dispose(animation);
_spSkeletonJson_setError(self, root, "spBone not found: ", boneMap->name);
return 0;
}
@ -143,13 +143,13 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
float duration;
if (strcmp(timelineArray->name, "rotate") == 0) {
RotateTimeline *timeline = RotateTimeline_create(timelineArray->size);
spRotateTimeline *timeline = spRotateTimeline_create(timelineArray->size);
timeline->boneIndex = boneIndex;
for (frame = timelineArray->child, i = 0; frame; frame = frame->next, ++i) {
RotateTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), Json_getFloat(frame, "angle", 0));
spRotateTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), Json_getFloat(frame, "angle", 0));
readCurve(SUPER(timeline), i, frame);
}
animation->timelines[animation->timelineCount++] = (Timeline*)timeline;
animation->timelines[animation->timelineCount++] = (spTimeline*)timeline;
duration = timeline->frames[timelineArray->size * 2 - 2];
if (duration > animation->duration) animation->duration = duration;
@ -157,20 +157,20 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
int isScale = strcmp(timelineArray->name, "scale") == 0;
if (isScale || strcmp(timelineArray->name, "translate") == 0) {
float scale = isScale ? 1 : self->scale;
TranslateTimeline *timeline =
isScale ? ScaleTimeline_create(timelineArray->size) : TranslateTimeline_create(timelineArray->size);
spTranslateTimeline *timeline =
isScale ? spScaleTimeline_create(timelineArray->size) : spTranslateTimeline_create(timelineArray->size);
timeline->boneIndex = boneIndex;
for (frame = timelineArray->child, i = 0; frame; frame = frame->next, ++i) {
TranslateTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), Json_getFloat(frame, "x", 0) * scale,
spTranslateTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), Json_getFloat(frame, "x", 0) * scale,
Json_getFloat(frame, "y", 0) * scale);
readCurve(SUPER(timeline), i, frame);
}
animation->timelines[animation->timelineCount++] = (Timeline*)timeline;
animation->timelines[animation->timelineCount++] = (spTimeline*)timeline;
duration = timeline->frames[timelineArray->size * 3 - 3];
if (duration > animation->duration) animation->duration = duration;
} else {
Animation_dispose(animation);
_SkeletonJson_setError(self, 0, "Invalid timeline type for a bone: ", timelineArray->name);
spAnimation_dispose(animation);
_spSkeletonJson_setError(self, 0, "Invalid timeline type for a bone: ", timelineArray->name);
return 0;
}
}
@ -180,10 +180,10 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
for (slotMap = slots ? slots->child : 0; slotMap; slotMap = slotMap->next) {
Json *timelineArray;
int slotIndex = SkeletonData_findSlotIndex(skeletonData, slotMap->name);
int slotIndex = spSkeletonData_findSlotIndex(skeletonData, slotMap->name);
if (slotIndex == -1) {
Animation_dispose(animation);
_SkeletonJson_setError(self, root, "Slot not found: ", slotMap->name);
spAnimation_dispose(animation);
_spSkeletonJson_setError(self, root, "Slot not found: ", slotMap->name);
return 0;
}
@ -192,33 +192,33 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
float duration;
if (strcmp(timelineArray->name, "color") == 0) {
ColorTimeline *timeline = ColorTimeline_create(timelineArray->size);
spColorTimeline *timeline = spColorTimeline_create(timelineArray->size);
timeline->slotIndex = slotIndex;
for (frame = timelineArray->child, i = 0; frame; frame = frame->next, ++i) {
const char* s = Json_getString(frame, "color", 0);
ColorTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), toColor(s, 0), toColor(s, 1), toColor(s, 2),
spColorTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), toColor(s, 0), toColor(s, 1), toColor(s, 2),
toColor(s, 3));
readCurve(SUPER(timeline), i, frame);
}
animation->timelines[animation->timelineCount++] = (Timeline*)timeline;
animation->timelines[animation->timelineCount++] = (spTimeline*)timeline;
duration = timeline->frames[timelineArray->size * 5 - 5];
if (duration > animation->duration) animation->duration = duration;
} else if (strcmp(timelineArray->name, "attachment") == 0) {
AttachmentTimeline *timeline = AttachmentTimeline_create(timelineArray->size);
spAttachmentTimeline *timeline = spAttachmentTimeline_create(timelineArray->size);
timeline->slotIndex = slotIndex;
for (frame = timelineArray->child, i = 0; frame; frame = frame->next, ++i) {
Json* name = Json_getItem(frame, "name");
AttachmentTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0),
spAttachmentTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0),
name->type == Json_NULL ? 0 : name->valueString);
}
animation->timelines[animation->timelineCount++] = (Timeline*)timeline;
animation->timelines[animation->timelineCount++] = (spTimeline*)timeline;
duration = timeline->frames[timelineArray->size - 1];
if (duration > animation->duration) animation->duration = duration;
} else {
Animation_dispose(animation);
_SkeletonJson_setError(self, 0, "Invalid timeline type for a slot: ", timelineArray->name);
spAnimation_dispose(animation);
_spSkeletonJson_setError(self, 0, "Invalid timeline type for a slot: ", timelineArray->name);
return 0;
}
}
@ -228,24 +228,24 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
Json* frame;
float duration;
EventTimeline* timeline = EventTimeline_create(events->size);
spEventTimeline* timeline = spEventTimeline_create(events->size);
for (frame = events->child, i = 0; frame; frame = frame->next, ++i) {
Event* event;
spEvent* event;
const char* stringValue;
EventData* eventData = SkeletonData_findEvent(skeletonData, Json_getString(frame, "name", 0));
spEventData* eventData = spSkeletonData_findEvent(skeletonData, Json_getString(frame, "name", 0));
if (!eventData) {
Animation_dispose(animation);
_SkeletonJson_setError(self, 0, "Event not found: ", Json_getString(frame, "name", 0));
spAnimation_dispose(animation);
_spSkeletonJson_setError(self, 0, "Event not found: ", Json_getString(frame, "name", 0));
return 0;
}
event = Event_create(eventData);
event = spEvent_create(eventData);
event->intValue = Json_getInt(frame, "int", eventData->intValue);
event->floatValue = Json_getFloat(frame, "float", eventData->floatValue);
stringValue = Json_getString(frame, "string", eventData->stringValue);
if (stringValue) MALLOC_STR(event->stringValue, stringValue);
EventTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), event);
spEventTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), event);
}
animation->timelines[animation->timelineCount++] = (Timeline*)timeline;
animation->timelines[animation->timelineCount++] = (spTimeline*)timeline;
duration = timeline->frames[events->size - 1];
if (duration > animation->duration) animation->duration = duration;
}
@ -254,7 +254,7 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
Json* frame;
float duration;
DrawOrderTimeline* timeline = DrawOrderTimeline_create(drawOrder->size, skeletonData->slotCount);
spDrawOrderTimeline* timeline = spDrawOrderTimeline_create(drawOrder->size, skeletonData->slotCount);
for (frame = drawOrder->child, i = 0; frame; frame = frame->next, ++i) {
int ii;
int* drawOrder = 0;
@ -269,10 +269,10 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
drawOrder[ii] = -1;
for (offsetMap = offsets->child; offsetMap; offsetMap = offsetMap->next) {
int slotIndex = SkeletonData_findSlotIndex(skeletonData, Json_getString(offsetMap, "slot", 0));
int slotIndex = spSkeletonData_findSlotIndex(skeletonData, Json_getString(offsetMap, "slot", 0));
if (slotIndex == -1) {
Animation_dispose(animation);
_SkeletonJson_setError(self, 0, "Slot not found: ", Json_getString(offsetMap, "slot", 0));
spAnimation_dispose(animation);
_spSkeletonJson_setError(self, 0, "Slot not found: ", Json_getString(offsetMap, "slot", 0));
return 0;
}
/* Collect unchanged items. */
@ -290,10 +290,10 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
if (drawOrder[ii] == -1) drawOrder[ii] = unchanged[--unchangedIndex];
FREE(unchanged);
}
DrawOrderTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), drawOrder);
spDrawOrderTimeline_setFrame(timeline, i, Json_getFloat(frame, "time", 0), drawOrder);
FREE(drawOrder);
}
animation->timelines[animation->timelineCount++] = (Timeline*)timeline;
animation->timelines[animation->timelineCount++] = (spTimeline*)timeline;
duration = timeline->frames[drawOrder->size - 1];
if (duration > animation->duration) animation->duration = duration;
}
@ -301,22 +301,22 @@ static Animation* _SkeletonJson_readAnimation (SkeletonJson* self, Json* root, S
return animation;
}
SkeletonData* SkeletonJson_readSkeletonDataFile (SkeletonJson* self, const char* path) {
spSkeletonData* spSkeletonJson_readSkeletonDataFile (spSkeletonJson* self, const char* path) {
int length;
SkeletonData* skeletonData;
const char* json = _Util_readFile(path, &length);
spSkeletonData* skeletonData;
const char* json = _spUtil_readFile(path, &length);
if (!json) {
_SkeletonJson_setError(self, 0, "Unable to read skeleton file: ", path);
_spSkeletonJson_setError(self, 0, "Unable to read skeleton file: ", path);
return 0;
}
skeletonData = SkeletonJson_readSkeletonData(self, json);
skeletonData = spSkeletonJson_readSkeletonData(self, json);
FREE(json);
return skeletonData;
}
SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* json) {
spSkeletonData* spSkeletonJson_readSkeletonData (spSkeletonJson* self, const char* json) {
int i;
SkeletonData* skeletonData;
spSkeletonData* skeletonData;
Json *root, *bones, *boneMap, *slots, *skins, *animations, *events;
FREE(self->error);
@ -324,29 +324,29 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
root = Json_create(json);
if (!root) {
_SkeletonJson_setError(self, 0, "Invalid skeleton JSON: ", Json_getError());
_spSkeletonJson_setError(self, 0, "Invalid skeleton JSON: ", Json_getError());
return 0;
}
skeletonData = SkeletonData_create();
skeletonData = spSkeletonData_create();
bones = Json_getItem(root, "bones");
skeletonData->bones = MALLOC(BoneData*, bones->size);
skeletonData->bones = MALLOC(spBoneData*, bones->size);
for (boneMap = bones->child, i = 0; boneMap; boneMap = boneMap->next, ++i) {
BoneData* boneData;
spBoneData* boneData;
BoneData* parent = 0;
spBoneData* parent = 0;
const char* parentName = Json_getString(boneMap, "parent", 0);
if (parentName) {
parent = SkeletonData_findBone(skeletonData, parentName);
parent = spSkeletonData_findBone(skeletonData, parentName);
if (!parent) {
SkeletonData_dispose(skeletonData);
_SkeletonJson_setError(self, root, "Parent bone not found: ", parentName);
spSkeletonData_dispose(skeletonData);
_spSkeletonJson_setError(self, root, "Parent bone not found: ", parentName);
return 0;
}
}
boneData = BoneData_create(Json_getString(boneMap, "name", 0), parent);
boneData = spBoneData_create(Json_getString(boneMap, "name", 0), parent);
boneData->length = Json_getFloat(boneMap, "length", 0) * self->scale;
boneData->x = Json_getFloat(boneMap, "x", 0) * self->scale;
boneData->y = Json_getFloat(boneMap, "y", 0) * self->scale;
@ -363,21 +363,21 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
slots = Json_getItem(root, "slots");
if (slots) {
Json *slotMap;
skeletonData->slots = MALLOC(SlotData*, slots->size);
skeletonData->slots = MALLOC(spSlotData*, slots->size);
for (slotMap = slots->child, i = 0; slotMap; slotMap = slotMap->next, ++i) {
SlotData* slotData;
spSlotData* slotData;
const char* color;
Json *attachmentItem;
const char* boneName = Json_getString(slotMap, "bone", 0);
BoneData* boneData = SkeletonData_findBone(skeletonData, boneName);
spBoneData* boneData = spSkeletonData_findBone(skeletonData, boneName);
if (!boneData) {
SkeletonData_dispose(skeletonData);
_SkeletonJson_setError(self, root, "Slot bone not found: ", boneName);
spSkeletonData_dispose(skeletonData);
_spSkeletonJson_setError(self, root, "spSlot bone not found: ", boneName);
return 0;
}
slotData = SlotData_create(Json_getString(slotMap, "name", 0), boneData);
slotData = spSlotData_create(Json_getString(slotMap, "name", 0), boneData);
color = Json_getString(slotMap, "color", 0);
if (color) {
@ -388,7 +388,7 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
}
attachmentItem = Json_getItem(slotMap, "attachment");
if (attachmentItem) SlotData_setAttachmentName(slotData, attachmentItem->valueString);
if (attachmentItem) spSlotData_setAttachmentName(slotData, attachmentItem->valueString);
slotData->additiveBlending = Json_getInt(slotMap, "additive", 0);
@ -400,26 +400,26 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
skins = Json_getItem(root, "skins");
if (skins) {
Json *slotMap;
skeletonData->skins = MALLOC(Skin*, skins->size);
skeletonData->skins = MALLOC(spSkin*, skins->size);
for (slotMap = skins->child, i = 0; slotMap; slotMap = slotMap->next, ++i) {
Json *attachmentsMap;
Skin *skin = Skin_create(slotMap->name);
spSkin *skin = spSkin_create(slotMap->name);
skeletonData->skins[i] = skin;
++skeletonData->skinCount;
if (strcmp(slotMap->name, "default") == 0) skeletonData->defaultSkin = skin;
for (attachmentsMap = slotMap->child; attachmentsMap; attachmentsMap = attachmentsMap->next) {
int slotIndex = SkeletonData_findSlotIndex(skeletonData, attachmentsMap->name);
int slotIndex = spSkeletonData_findSlotIndex(skeletonData, attachmentsMap->name);
Json *attachmentMap;
for (attachmentMap = attachmentsMap->child; attachmentMap; attachmentMap = attachmentMap->next) {
Attachment* attachment;
spAttachment* attachment;
const char* skinAttachmentName = attachmentMap->name;
const char* attachmentName = Json_getString(attachmentMap, "name", skinAttachmentName);
const char* typeString = Json_getString(attachmentMap, "type", "region");
AttachmentType type;
spAttachmentType type;
if (strcmp(typeString, "region") == 0)
type = ATTACHMENT_REGION;
else if (strcmp(typeString, "boundingbox") == 0)
@ -427,16 +427,16 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
else if (strcmp(typeString, "regionsequence") == 0)
type = ATTACHMENT_REGION_SEQUENCE;
else {
SkeletonData_dispose(skeletonData);
_SkeletonJson_setError(self, root, "Unknown attachment type: ", typeString);
spSkeletonData_dispose(skeletonData);
_spSkeletonJson_setError(self, root, "Unknown attachment type: ", typeString);
return 0;
}
attachment = AttachmentLoader_newAttachment(self->attachmentLoader, skin, type, attachmentName);
attachment = spAttachmentLoader_newAttachment(self->attachmentLoader, skin, type, attachmentName);
if (!attachment) {
if (self->attachmentLoader->error1) {
SkeletonData_dispose(skeletonData);
_SkeletonJson_setError(self, root, self->attachmentLoader->error1, self->attachmentLoader->error2);
spSkeletonData_dispose(skeletonData);
_spSkeletonJson_setError(self, root, self->attachmentLoader->error1, self->attachmentLoader->error2);
return 0;
}
continue;
@ -445,7 +445,7 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
switch (attachment->type) {
case ATTACHMENT_REGION:
case ATTACHMENT_REGION_SEQUENCE: {
RegionAttachment* regionAttachment = (RegionAttachment*)attachment;
spRegionAttachment* regionAttachment = (spRegionAttachment*)attachment;
regionAttachment->x = Json_getFloat(attachmentMap, "x", 0) * self->scale;
regionAttachment->y = Json_getFloat(attachmentMap, "y", 0) * self->scale;
regionAttachment->scaleX = Json_getFloat(attachmentMap, "scaleX", 1);
@ -453,11 +453,11 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
regionAttachment->rotation = Json_getFloat(attachmentMap, "rotation", 0);
regionAttachment->width = Json_getFloat(attachmentMap, "width", 32) * self->scale;
regionAttachment->height = Json_getFloat(attachmentMap, "height", 32) * self->scale;
RegionAttachment_updateOffset(regionAttachment);
spRegionAttachment_updateOffset(regionAttachment);
break;
}
case ATTACHMENT_BOUNDING_BOX: {
BoundingBoxAttachment* box = (BoundingBoxAttachment*)attachment;
spBoundingBoxAttachment* box = (spBoundingBoxAttachment*)attachment;
Json* verticesArray = Json_getItem(attachmentMap, "vertices");
Json* vertex;
int i;
@ -469,7 +469,7 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
}
}
Skin_addAttachment(skin, slotIndex, skinAttachmentName, attachment);
spSkin_addAttachment(skin, slotIndex, skinAttachmentName, attachment);
}
}
}
@ -480,9 +480,9 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
if (events) {
Json *eventMap;
const char* stringValue;
skeletonData->events = MALLOC(EventData*, events->size);
skeletonData->events = MALLOC(spEventData*, events->size);
for (eventMap = events->child; eventMap; eventMap = eventMap->next) {
EventData* eventData = EventData_create(eventMap->name);
spEventData* eventData = spEventData_create(eventMap->name);
eventData->intValue = Json_getInt(eventMap, "int", 0);
eventData->floatValue = Json_getFloat(eventMap, "float", 0);
stringValue = Json_getString(eventMap, "string", 0);
@ -495,9 +495,9 @@ SkeletonData* SkeletonJson_readSkeletonData (SkeletonJson* self, const char* jso
animations = Json_getItem(root, "animations");
if (animations) {
Json *animationMap;
skeletonData->animations = MALLOC(Animation*, animations->size);
skeletonData->animations = MALLOC(spAnimation*, animations->size);
for (animationMap = animations->child; animationMap; animationMap = animationMap->next)
_SkeletonJson_readAnimation(self, animationMap, skeletonData);
_spSkeletonJson_readAnimation(self, animationMap, skeletonData);
}
Json_dispose(root);

42
spine-c/src/spine/Skin.c
View File

@ -38,11 +38,11 @@ typedef struct _Entry _Entry;
struct _Entry {
int slotIndex;
const char* name;
Attachment* attachment;
spAttachment* attachment;
_Entry* next;
};
_Entry* _Entry_create (int slotIndex, const char* name, Attachment* attachment) {
_Entry* _Entry_create (int slotIndex, const char* name, spAttachment* attachment) {
_Entry* self = NEW(_Entry);
self->slotIndex = slotIndex;
MALLOC_STR(self->name, name);
@ -51,7 +51,7 @@ _Entry* _Entry_create (int slotIndex, const char* name, Attachment* attachment)
}
void _Entry_dispose (_Entry* self) {
Attachment_dispose(self->attachment);
spAttachment_dispose(self->attachment);
FREE(self->name);
FREE(self);
}
@ -59,18 +59,18 @@ void _Entry_dispose (_Entry* self) {
/**/
typedef struct {
Skin super;
spSkin super;
_Entry* entries;
} _Skin;
} _spSkin;
Skin* Skin_create (const char* name) {
Skin* self = SUPER(NEW(_Skin));
spSkin* spSkin_create (const char* name) {
spSkin* self = SUPER(NEW(_spSkin));
MALLOC_STR(self->name, name);
return self;
}
void Skin_dispose (Skin* self) {
_Entry* entry = SUB_CAST(_Skin, self)->entries;
void spSkin_dispose (spSkin* self) {
_Entry* entry = SUB_CAST(_spSkin, self)->entries;
while (entry) {
_Entry* nextEntry = entry->next;
_Entry_dispose(entry);
@ -81,14 +81,14 @@ void Skin_dispose (Skin* self) {
FREE(self);
}
void Skin_addAttachment (Skin* self, int slotIndex, const char* name, Attachment* attachment) {
void spSkin_addAttachment (spSkin* self, int slotIndex, const char* name, spAttachment* attachment) {
_Entry* newEntry = _Entry_create(slotIndex, name, attachment);
newEntry->next = SUB_CAST(_Skin, self)->entries;
SUB_CAST(_Skin, self)->entries = newEntry;
newEntry->next = SUB_CAST(_spSkin, self)->entries;
SUB_CAST(_spSkin, self)->entries = newEntry;
}
Attachment* Skin_getAttachment (const Skin* self, int slotIndex, const char* name) {
const _Entry* entry = SUB_CAST(_Skin, self)->entries;
spAttachment* spSkin_getAttachment (const spSkin* self, int slotIndex, const char* name) {
const _Entry* entry = SUB_CAST(_spSkin, self)->entries;
while (entry) {
if (entry->slotIndex == slotIndex && strcmp(entry->name, name) == 0) return entry->attachment;
entry = entry->next;
@ -96,8 +96,8 @@ Attachment* Skin_getAttachment (const Skin* self, int slotIndex, const char* nam
return 0;
}
const char* Skin_getAttachmentName (const Skin* self, int slotIndex, int attachmentIndex) {
const _Entry* entry = SUB_CAST(_Skin, self)->entries;
const char* spSkin_getAttachmentName (const spSkin* self, int slotIndex, int attachmentIndex) {
const _Entry* entry = SUB_CAST(_spSkin, self)->entries;
int i = 0;
while (entry) {
if (entry->slotIndex == slotIndex) {
@ -109,13 +109,13 @@ const char* Skin_getAttachmentName (const Skin* self, int slotIndex, int attachm
return 0;
}
void Skin_attachAll (const Skin* self, Skeleton* skeleton, const Skin* oldSkin) {
const _Entry *entry = SUB_CAST(_Skin, oldSkin)->entries;
void spSkin_attachAll (const spSkin* self, spSkeleton* skeleton, const spSkin* oldSkin) {
const _Entry *entry = SUB_CAST(_spSkin, oldSkin)->entries;
while (entry) {
Slot *slot = skeleton->slots[entry->slotIndex];
spSlot *slot = skeleton->slots[entry->slotIndex];
if (slot->attachment == entry->attachment) {
Attachment *attachment = Skin_getAttachment(self, entry->slotIndex, entry->name);
if (attachment) Slot_setAttachment(slot, attachment);
spAttachment *attachment = spSkin_getAttachment(self, entry->slotIndex, entry->name);
if (attachment) spSlot_setAttachment(slot, attachment);
}
entry = entry->next;
}

40
spine-c/src/spine/Slot.c
View File

@ -36,38 +36,38 @@
#include <spine/Skeleton.h>
typedef struct {
Slot super;
spSlot super;
float attachmentTime;
} _Slot;
} _spSlot;
Slot* Slot_create (SlotData* data, Skeleton* skeleton, Bone* bone) {
Slot* self = SUPER(NEW(_Slot));
CONST_CAST(SlotData*, self->data) = data;
CONST_CAST(Skeleton*, self->skeleton) = skeleton;
CONST_CAST(Bone*, self->bone) = bone;
Slot_setToSetupPose(self);
spSlot* spSlot_create (spSlotData* data, spSkeleton* skeleton, spBone* bone) {
spSlot* self = SUPER(NEW(_spSlot));
CONST_CAST(spSlotData*, self->data) = data;
CONST_CAST(spSkeleton*, self->skeleton) = skeleton;
CONST_CAST(spBone*, self->bone) = bone;
spSlot_setToSetupPose(self);
return self;
}
void Slot_dispose (Slot* self) {
void spSlot_dispose (spSlot* self) {
FREE(self);
}
void Slot_setAttachment (Slot* self, Attachment* attachment) {
CONST_CAST(Attachment*, self->attachment) = attachment;
SUB_CAST(_Slot, self) ->attachmentTime = self->skeleton->time;
void spSlot_setAttachment (spSlot* self, spAttachment* attachment) {
CONST_CAST(spAttachment*, self->attachment) = attachment;
SUB_CAST(_spSlot, self) ->attachmentTime = self->skeleton->time;
}
void Slot_setAttachmentTime (Slot* self, float time) {
SUB_CAST(_Slot, self) ->attachmentTime = self->skeleton->time - time;
void spSlot_setAttachmentTime (spSlot* self, float time) {
SUB_CAST(_spSlot, self) ->attachmentTime = self->skeleton->time - time;
}
float Slot_getAttachmentTime (const Slot* self) {
return self->skeleton->time - SUB_CAST(_Slot, self) ->attachmentTime;
float spSlot_getAttachmentTime (const spSlot* self) {
return self->skeleton->time - SUB_CAST(_spSlot, self) ->attachmentTime;
}
void Slot_setToSetupPose (Slot* self) {
Attachment* attachment = 0;
void spSlot_setToSetupPose (spSlot* self) {
spAttachment* attachment = 0;
self->r = self->data->r;
self->g = self->data->g;
self->b = self->data->b;
@ -78,10 +78,10 @@ void Slot_setToSetupPose (Slot* self) {
int i;
for (i = 0; i < self->skeleton->data->slotCount; ++i) {
if (self->data == self->skeleton->data->slots[i]) {
attachment = Skeleton_getAttachmentForSlotIndex(self->skeleton, i, self->data->attachmentName);
attachment = spSkeleton_getAttachmentForSlotIndex(self->skeleton, i, self->data->attachmentName);
break;
}
}
}
Slot_setAttachment(self, attachment);
spSlot_setAttachment(self, attachment);
}

10
spine-c/src/spine/SlotData.c
View File

@ -34,10 +34,10 @@
#include <spine/SlotData.h>
#include <spine/extension.h>
SlotData* SlotData_create (const char* name, BoneData* boneData) {
SlotData* self = NEW(SlotData);
spSlotData* spSlotData_create (const char* name, spBoneData* boneData) {
spSlotData* self = NEW(spSlotData);
MALLOC_STR(self->name, name);
CONST_CAST(BoneData*, self->boneData) = boneData;
CONST_CAST(spBoneData*, self->boneData) = boneData;
self->r = 1;
self->g = 1;
self->b = 1;
@ -45,13 +45,13 @@ SlotData* SlotData_create (const char* name, BoneData* boneData) {
return self;
}
void SlotData_dispose (SlotData* self) {
void spSlotData_dispose (spSlotData* self) {
FREE(self->name);
FREE(self->attachmentName);
FREE(self);
}
void SlotData_setAttachmentName (SlotData* self, const char* attachmentName) {
void spSlotData_setAttachmentName (spSlotData* self, const char* attachmentName) {
FREE(self->attachmentName);
if (attachmentName)
MALLOC_STR(self->attachmentName, attachmentName);

1
spine-cocos2d-iphone/src/spine/CCSkeleton.h
View File

@ -31,6 +31,7 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*****************************************************************************/
#define SPINE_SHORT_NAMES
#import <spine/spine.h>
#import "cocos2d.h"

1
spine-cocos2d-iphone/src/spine/CCSkeletonAnimation.h
View File

@ -31,6 +31,7 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*****************************************************************************/
#define SPINE_SHORT_NAMES
#import <spine/spine.h>
#import <spine/CCSkeleton.h>
#import "cocos2d.h"

1
spine-cocos2d-iphone/src/spine/spine-cocos2d-iphone.h
View File

@ -31,6 +31,7 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*****************************************************************************/
#define SPINE_SHORT_NAMES
#import <spine/spine.h>
#import "cocos2d.h"
#import "CCSkeleton.h"

4
spine-cocos2dx/example/Classes/ExampleLayer.cpp
View File

@ -51,8 +51,8 @@ void ExampleLayer::update (float deltaTime) {
// if (entry->time > 0.1) CCDirector::sharedDirector()->replaceScene(ExampleLayer::scene());
}
void ExampleLayer::animationStateEvent (CCSkeletonAnimation* node, int trackIndex, EventType type, Event* event, int loopCount) {
TrackEntry* entry = AnimationState_getCurrent(node->state, trackIndex);
void ExampleLayer::animationStateEvent (CCSkeletonAnimation* node, int trackIndex, spEventType type, spEvent* event, int loopCount) {
spTrackEntry* entry = spAnimationState_getCurrent(node->state, trackIndex);
const char* animationName = (entry && entry->animation) ? entry->animation->name : 0;
switch (type) {

2
spine-cocos2dx/example/Classes/ExampleLayer.h
View File

@ -17,7 +17,7 @@ public:
private:
spine::CCSkeletonAnimation* skeletonNode;
void animationStateEvent (spine::CCSkeletonAnimation* node, int trackIndex, EventType type, Event* event, int loopCount);
void animationStateEvent (spine::CCSkeletonAnimation* node, int trackIndex, spEventType type, spEvent* event, int loopCount);
};
#endif // _EXAMPLELAYER_H_

84
spine-cocos2dx/src/spine/CCSkeleton.cpp
View File

@ -40,13 +40,13 @@ using std::max;
namespace spine {
CCSkeleton* CCSkeleton::createWithData (SkeletonData* skeletonData, bool ownsSkeletonData) {
CCSkeleton* CCSkeleton::createWithData (spSkeletonData* skeletonData, bool ownsSkeletonData) {
CCSkeleton* node = new CCSkeleton(skeletonData, ownsSkeletonData);
node->autorelease();
return node;
}
CCSkeleton* CCSkeleton::createWithFile (const char* skeletonDataFile, Atlas* atlas, float scale) {
CCSkeleton* CCSkeleton::createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale) {
CCSkeleton* node = new CCSkeleton(skeletonDataFile, atlas, scale);
node->autorelease();
return node;
@ -72,8 +72,8 @@ void CCSkeleton::initialize () {
scheduleUpdate();
}
void CCSkeleton::setSkeletonData (SkeletonData *skeletonData, bool ownsSkeletonData) {
skeleton = Skeleton_create(skeletonData);
void CCSkeleton::setSkeletonData (spSkeletonData *skeletonData, bool ownsSkeletonData) {
skeleton = spSkeleton_create(skeletonData);
rootBone = skeleton->bones[0];
this->ownsSkeletonData = ownsSkeletonData;
}
@ -82,20 +82,20 @@ CCSkeleton::CCSkeleton () {
initialize();
}
CCSkeleton::CCSkeleton (SkeletonData *skeletonData, bool ownsSkeletonData) {
CCSkeleton::CCSkeleton (spSkeletonData *skeletonData, bool ownsSkeletonData) {
initialize();
setSkeletonData(skeletonData, ownsSkeletonData);
}
CCSkeleton::CCSkeleton (const char* skeletonDataFile, Atlas* atlas, float scale) {
CCSkeleton::CCSkeleton (const char* skeletonDataFile, spAtlas* atlas, float scale) {
initialize();
SkeletonJson* json = SkeletonJson_create(atlas);
spSkeletonJson* json = spSkeletonJson_create(atlas);
json->scale = scale;
SkeletonData* skeletonData = SkeletonJson_readSkeletonDataFile(json, skeletonDataFile);
spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile);
CCAssert(skeletonData, json->error ? json->error : "Error reading skeleton data.");
SkeletonJson_dispose(json);
spSkeletonJson_dispose(json);
setSkeletonData(skeletonData, true);
}
@ -103,26 +103,26 @@ CCSkeleton::CCSkeleton (const char* skeletonDataFile, Atlas* atlas, float scale)
CCSkeleton::CCSkeleton (const char* skeletonDataFile, const char* atlasFile, float scale) {
initialize();
atlas = Atlas_readAtlasFile(atlasFile);
atlas = spAtlas_readAtlasFile(atlasFile);
CCAssert(atlas, "Error reading atlas file.");
SkeletonJson* json = SkeletonJson_create(atlas);
spSkeletonJson* json = spSkeletonJson_create(atlas);
json->scale = scale;
SkeletonData* skeletonData = SkeletonJson_readSkeletonDataFile(json, skeletonDataFile);
spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile);
CCAssert(skeletonData, json->error ? json->error : "Error reading skeleton data file.");
SkeletonJson_dispose(json);
spSkeletonJson_dispose(json);
setSkeletonData(skeletonData, true);
}
CCSkeleton::~CCSkeleton () {
if (ownsSkeletonData) SkeletonData_dispose(skeleton->data);
if (atlas) Atlas_dispose(atlas);
Skeleton_dispose(skeleton);
if (ownsSkeletonData) spSkeletonData_dispose(skeleton->data);
if (atlas) spAtlas_dispose(atlas);
spSkeleton_dispose(skeleton);
}
void CCSkeleton::update (float deltaTime) {
Skeleton_update(skeleton, deltaTime * timeScale);
spSkeleton_update(skeleton, deltaTime * timeScale);
}
void CCSkeleton::draw () {
@ -148,9 +148,9 @@ void CCSkeleton::draw () {
quad.bl.vertices.z = 0;
quad.br.vertices.z = 0;
for (int i = 0, n = skeleton->slotCount; i < n; i++) {
Slot* slot = skeleton->drawOrder[i];
spSlot* slot = skeleton->drawOrder[i];
if (!slot->attachment || slot->attachment->type != ATTACHMENT_REGION) continue;
RegionAttachment* attachment = (RegionAttachment*)slot->attachment;
spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment;
CCTextureAtlas* regionTextureAtlas = getTextureAtlas(attachment);
if (slot->data->additiveBlending != additive) {
@ -173,7 +173,7 @@ void CCSkeleton::draw () {
if (!textureAtlas->resizeCapacity(textureAtlas->getCapacity() * 2)) return;
}
RegionAttachment_updateQuad(attachment, slot, &quad, premultipliedAlpha);
spRegionAttachment_updateQuad(attachment, slot, &quad, premultipliedAlpha);
textureAtlas->updateQuad(&quad, quadCount);
}
if (textureAtlas) {
@ -188,10 +188,10 @@ void CCSkeleton::draw () {
CCPoint points[4];
ccV3F_C4B_T2F_Quad quad;
for (int i = 0, n = skeleton->slotCount; i < n; i++) {
Slot* slot = skeleton->drawOrder[i];
spSlot* slot = skeleton->drawOrder[i];
if (!slot->attachment || slot->attachment->type != ATTACHMENT_REGION) continue;
RegionAttachment* attachment = (RegionAttachment*)slot->attachment;
RegionAttachment_updateQuad(attachment, slot, &quad);
spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment;
spRegionAttachment_updateQuad(attachment, slot, &quad);
points[0] = ccp(quad.bl.vertices.x, quad.bl.vertices.y);
points[1] = ccp(quad.br.vertices.x, quad.br.vertices.y);
points[2] = ccp(quad.tr.vertices.x, quad.tr.vertices.y);
@ -204,7 +204,7 @@ void CCSkeleton::draw () {
glLineWidth(2);
ccDrawColor4B(255, 0, 0, 255);
for (int i = 0, n = skeleton->boneCount; i < n; i++) {
Bone *bone = skeleton->bones[i];
spBone *bone = skeleton->bones[i];
float x = bone->data->length * bone->m00 + bone->worldX;
float y = bone->data->length * bone->m10 + bone->worldY;
ccDrawLine(ccp(bone->worldX, bone->worldY), ccp(x, y));
@ -213,15 +213,15 @@ void CCSkeleton::draw () {
ccPointSize(4);
ccDrawColor4B(0, 0, 255, 255); // Root bone is blue.
for (int i = 0, n = skeleton->boneCount; i < n; i++) {
Bone *bone = skeleton->bones[i];
spBone *bone = skeleton->bones[i];
ccDrawPoint(ccp(bone->worldX, bone->worldY));
if (i == 0) ccDrawColor4B(0, 255, 0, 255);
}
}
}
CCTextureAtlas* CCSkeleton::getTextureAtlas (RegionAttachment* regionAttachment) const {
return (CCTextureAtlas*)((AtlasRegion*)regionAttachment->rendererObject)->page->rendererObject;
CCTextureAtlas* CCSkeleton::getTextureAtlas (spRegionAttachment* regionAttachment) const {
return (CCTextureAtlas*)((spAtlasRegion*)regionAttachment->rendererObject)->page->rendererObject;
}
CCRect CCSkeleton::boundingBox () {
@ -230,10 +230,10 @@ CCRect CCSkeleton::boundingBox () {
float scaleY = getScaleY();
float vertices[8];
for (int i = 0; i < skeleton->slotCount; ++i) {
Slot* slot = skeleton->slots[i];
spSlot* slot = skeleton->slots[i];
if (!slot->attachment || slot->attachment->type != ATTACHMENT_REGION) continue;
RegionAttachment* attachment = (RegionAttachment*)slot->attachment;
RegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, vertices);
spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment;
spRegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, vertices);
minX = min(minX, vertices[VERTEX_X1] * scaleX);
minY = min(minY, vertices[VERTEX_Y1] * scaleY);
maxX = max(maxX, vertices[VERTEX_X1] * scaleX);
@ -258,36 +258,36 @@ CCRect CCSkeleton::boundingBox () {
// --- Convenience methods for Skeleton_* functions.
void CCSkeleton::updateWorldTransform () {
Skeleton_updateWorldTransform(skeleton);
spSkeleton_updateWorldTransform(skeleton);
}
void CCSkeleton::setToSetupPose () {
Skeleton_setToSetupPose(skeleton);
spSkeleton_setToSetupPose(skeleton);
}
void CCSkeleton::setBonesToSetupPose () {
Skeleton_setBonesToSetupPose(skeleton);
spSkeleton_setBonesToSetupPose(skeleton);
}
void CCSkeleton::setSlotsToSetupPose () {
Skeleton_setSlotsToSetupPose(skeleton);
spSkeleton_setSlotsToSetupPose(skeleton);
}
Bone* CCSkeleton::findBone (const char* boneName) const {
return Skeleton_findBone(skeleton, boneName);
spBone* CCSkeleton::findBone (const char* boneName) const {
return spSkeleton_findBone(skeleton, boneName);
}
Slot* CCSkeleton::findSlot (const char* slotName) const {
return Skeleton_findSlot(skeleton, slotName);
spSlot* CCSkeleton::findSlot (const char* slotName) const {
return spSkeleton_findSlot(skeleton, slotName);
}
bool CCSkeleton::setSkin (const char* skinName) {
return Skeleton_setSkinByName(skeleton, skinName) ? true : false;
return spSkeleton_setSkinByName(skeleton, skinName) ? true : false;
}
Attachment* CCSkeleton::getAttachment (const char* slotName, const char* attachmentName) const {
return Skeleton_getAttachmentForSlotName(skeleton, slotName, attachmentName);
spAttachment* CCSkeleton::getAttachment (const char* slotName, const char* attachmentName) const {
return spSkeleton_getAttachmentForSlotName(skeleton, slotName, attachmentName);
}
bool CCSkeleton::setAttachment (const char* slotName, const char* attachmentName) {
return Skeleton_setAttachment(skeleton, slotName, attachmentName) ? true : false;
return spSkeleton_setAttachment(skeleton, slotName, attachmentName) ? true : false;
}
// --- CCBlendProtocol

24
spine-cocos2dx/src/spine/CCSkeleton.h
View File

@ -42,19 +42,19 @@ namespace spine {
/** Draws a skeleton. */
class CCSkeleton: public cocos2d::CCNodeRGBA, public cocos2d::CCBlendProtocol {
public:
Skeleton* skeleton;
Bone* rootBone;
spSkeleton* skeleton;
spBone* rootBone;
float timeScale;
bool debugSlots;
bool debugBones;
bool premultipliedAlpha;
static CCSkeleton* createWithData (SkeletonData* skeletonData, bool ownsSkeletonData = false);
static CCSkeleton* createWithFile (const char* skeletonDataFile, Atlas* atlas, float scale = 1);
static CCSkeleton* createWithData (spSkeletonData* skeletonData, bool ownsSkeletonData = false);
static CCSkeleton* createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale = 1);
static CCSkeleton* createWithFile (const char* skeletonDataFile, const char* atlasFile, float scale = 1);
CCSkeleton (SkeletonData* skeletonData, bool ownsSkeletonData = false);
CCSkeleton (const char* skeletonDataFile, Atlas* atlas, float scale = 1);
CCSkeleton (spSkeletonData* skeletonData, bool ownsSkeletonData = false);
CCSkeleton (const char* skeletonDataFile, spAtlas* atlas, float scale = 1);
CCSkeleton (const char* skeletonDataFile, const char* atlasFile, float scale = 1);
virtual ~CCSkeleton ();
@ -71,9 +71,9 @@ public:
void setSlotsToSetupPose ();
/* Returns 0 if the bone was not found. */
Bone* findBone (const char* boneName) const;
spBone* findBone (const char* boneName) const;
/* Returns 0 if the slot was not found. */
Slot* findSlot (const char* slotName) const;
spSlot* findSlot (const char* slotName) const;
/* Sets the skin used to look up attachments not found in the SkeletonData defaultSkin. Attachments from the new skin are
* attached if the corresponding attachment from the old skin was attached. Returns false if the skin was not found.
@ -81,7 +81,7 @@ public:
bool setSkin (const char* skinName);
/* Returns 0 if the slot or attachment was not found. */
Attachment* getAttachment (const char* slotName, const char* attachmentName) const;
spAttachment* getAttachment (const char* slotName, const char* attachmentName) const;
/* Returns false if the slot or attachment was not found. */
bool setAttachment (const char* slotName, const char* attachmentName);
@ -92,12 +92,12 @@ public:
protected:
CCSkeleton ();
void setSkeletonData (SkeletonData* skeletonData, bool ownsSkeletonData);
cocos2d::CCTextureAtlas* getTextureAtlas (RegionAttachment* regionAttachment) const;
void setSkeletonData (spSkeletonData* skeletonData, bool ownsSkeletonData);
cocos2d::CCTextureAtlas* getTextureAtlas (spRegionAttachment* regionAttachment) const;
private:
bool ownsSkeletonData;
Atlas* atlas;
spAtlas* atlas;
void initialize ();
};

54
spine-cocos2dx/src/spine/CCSkeletonAnimation.cpp
View File

@ -42,17 +42,17 @@ using std::vector;
namespace spine {
static void callback (AnimationState* state, int trackIndex, EventType type, Event* event, int loopCount) {
static void callback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) {
((CCSkeletonAnimation*)state->context)->onAnimationStateEvent(trackIndex, type, event, loopCount);
}
CCSkeletonAnimation* CCSkeletonAnimation::createWithData (SkeletonData* skeletonData) {
CCSkeletonAnimation* CCSkeletonAnimation::createWithData (spSkeletonData* skeletonData) {
CCSkeletonAnimation* node = new CCSkeletonAnimation(skeletonData);
node->autorelease();
return node;
}
CCSkeletonAnimation* CCSkeletonAnimation::createWithFile (const char* skeletonDataFile, Atlas* atlas, float scale) {
CCSkeletonAnimation* CCSkeletonAnimation::createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale) {
CCSkeletonAnimation* node = new CCSkeletonAnimation(skeletonDataFile, atlas, scale);
node->autorelease();
return node;
@ -68,17 +68,17 @@ void CCSkeletonAnimation::initialize () {
listenerInstance = 0;
listenerMethod = 0;
state = AnimationState_create(AnimationStateData_create(skeleton->data));
state = spAnimationState_create(spAnimationStateData_create(skeleton->data));
state->context = this;
state->listener = callback;
}
CCSkeletonAnimation::CCSkeletonAnimation (SkeletonData *skeletonData)
CCSkeletonAnimation::CCSkeletonAnimation (spSkeletonData *skeletonData)
: CCSkeleton(skeletonData) {
initialize();
}
CCSkeletonAnimation::CCSkeletonAnimation (const char* skeletonDataFile, Atlas* atlas, float scale)
CCSkeletonAnimation::CCSkeletonAnimation (const char* skeletonDataFile, spAtlas* atlas, float scale)
: CCSkeleton(skeletonDataFile, atlas, scale) {
initialize();
}
@ -89,33 +89,33 @@ CCSkeletonAnimation::CCSkeletonAnimation (const char* skeletonDataFile, const ch
}
CCSkeletonAnimation::~CCSkeletonAnimation () {
if (ownsAnimationStateData) AnimationStateData_dispose(state->data);
AnimationState_dispose(state);
if (ownsAnimationStateData) spAnimationStateData_dispose(state->data);
spAnimationState_dispose(state);
}
void CCSkeletonAnimation::update (float deltaTime) {
super::update(deltaTime);
deltaTime *= timeScale;
AnimationState_update(state, deltaTime);
AnimationState_apply(state, skeleton);
Skeleton_updateWorldTransform(skeleton);
spAnimationState_update(state, deltaTime);
spAnimationState_apply(state, skeleton);
spSkeleton_updateWorldTransform(skeleton);
}
void CCSkeletonAnimation::setAnimationStateData (AnimationStateData* stateData) {
void CCSkeletonAnimation::setAnimationStateData (spAnimationStateData* stateData) {
CCAssert(stateData, "stateData cannot be null.");
if (ownsAnimationStateData) AnimationStateData_dispose(state->data);
AnimationState_dispose(state);
if (ownsAnimationStateData) spAnimationStateData_dispose(state->data);
spAnimationState_dispose(state);
ownsAnimationStateData = true;
state = AnimationState_create(stateData);
state = spAnimationState_create(stateData);
state->context = this;
state->listener = callback;
}
void CCSkeletonAnimation::setMix (const char* fromAnimation, const char* toAnimation, float duration) {
AnimationStateData_setMixByName(state->data, fromAnimation, toAnimation, duration);
spAnimationStateData_setMixByName(state->data, fromAnimation, toAnimation, duration);
}
void CCSkeletonAnimation::setAnimationListener (CCObject* instance, SEL_AnimationStateEvent method) {
@ -123,37 +123,37 @@ void CCSkeletonAnimation::setAnimationListener (CCObject* instance, SEL_Animatio
listenerMethod = method;
}
TrackEntry* CCSkeletonAnimation::setAnimation (int trackIndex, const char* name, bool loop) {
Animation* animation = SkeletonData_findAnimation(skeleton->data, name);
spTrackEntry* CCSkeletonAnimation::setAnimation (int trackIndex, const char* name, bool loop) {
spAnimation* animation = spSkeletonData_findAnimation(skeleton->data, name);
if (!animation) {
CCLog("Spine: Animation not found: %s", name);
return 0;
}
return AnimationState_setAnimation(state, trackIndex, animation, loop);
return spAnimationState_setAnimation(state, trackIndex, animation, loop);
}
TrackEntry* CCSkeletonAnimation::addAnimation (int trackIndex, const char* name, bool loop, float delay) {
Animation* animation = SkeletonData_findAnimation(skeleton->data, name);
spTrackEntry* CCSkeletonAnimation::addAnimation (int trackIndex, const char* name, bool loop, float delay) {
spAnimation* animation = spSkeletonData_findAnimation(skeleton->data, name);
if (!animation) {
CCLog("Spine: Animation not found: %s", name);
return 0;
}
return AnimationState_addAnimation(state, trackIndex, animation, loop, delay);
return spAnimationState_addAnimation(state, trackIndex, animation, loop, delay);
}
TrackEntry* CCSkeletonAnimation::getCurrent (int trackIndex) {
return AnimationState_getCurrent(state, trackIndex);
spTrackEntry* CCSkeletonAnimation::getCurrent (int trackIndex) {
return spAnimationState_getCurrent(state, trackIndex);
}
void CCSkeletonAnimation::clearTracks () {
AnimationState_clearTracks(state);
spAnimationState_clearTracks(state);
}
void CCSkeletonAnimation::clearTrack (int trackIndex) {
AnimationState_clearTrack(state, trackIndex);
spAnimationState_clearTrack(state, trackIndex);
}
void CCSkeletonAnimation::onAnimationStateEvent (int trackIndex, EventType type, Event* event, int loopCount) {
void CCSkeletonAnimation::onAnimationStateEvent (int trackIndex, spEventType type, spEvent* event, int loopCount) {
if (listenerInstance) (listenerInstance->*listenerMethod)(this, trackIndex, type, event, loopCount);
}

22
spine-cocos2dx/src/spine/CCSkeletonAnimation.h
View File

@ -41,38 +41,38 @@
namespace spine {
class CCSkeletonAnimation;
typedef void (cocos2d::CCObject::*SEL_AnimationStateEvent)(spine::CCSkeletonAnimation* node, int trackIndex, EventType type, Event* event, int loopCount);
typedef void (cocos2d::CCObject::*SEL_AnimationStateEvent)(spine::CCSkeletonAnimation* node, int trackIndex, spEventType type, spEvent* event, int loopCount);
#define animationStateEvent_selector(_SELECTOR) (SEL_AnimationStateEvent)(&_SELECTOR)
/** Draws an animated skeleton, providing an AnimationState for applying one or more animations and queuing animations to be
* played later. */
class CCSkeletonAnimation: public CCSkeleton {
public:
AnimationState* state;
spAnimationState* state;
static CCSkeletonAnimation* createWithData (SkeletonData* skeletonData);
static CCSkeletonAnimation* createWithFile (const char* skeletonDataFile, Atlas* atlas, float scale = 1);
static CCSkeletonAnimation* createWithData (spSkeletonData* skeletonData);
static CCSkeletonAnimation* createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale = 1);
static CCSkeletonAnimation* createWithFile (const char* skeletonDataFile, const char* atlasFile, float scale = 1);
CCSkeletonAnimation (SkeletonData* skeletonData);
CCSkeletonAnimation (const char* skeletonDataFile, Atlas* atlas, float scale = 1);
CCSkeletonAnimation (spSkeletonData* skeletonData);
CCSkeletonAnimation (const char* skeletonDataFile, spAtlas* atlas, float scale = 1);
CCSkeletonAnimation (const char* skeletonDataFile, const char* atlasFile, float scale = 1);
virtual ~CCSkeletonAnimation ();
virtual void update (float deltaTime);
void setAnimationStateData (AnimationStateData* stateData);
void setAnimationStateData (spAnimationStateData* stateData);
void setMix (const char* fromAnimation, const char* toAnimation, float duration);
void setAnimationListener (CCObject* instance, SEL_AnimationStateEvent method);
TrackEntry* setAnimation (int trackIndex, const char* name, bool loop);
TrackEntry* addAnimation (int trackIndex, const char* name, bool loop, float delay = 0);
TrackEntry* getCurrent (int trackIndex = 0);
spTrackEntry* setAnimation (int trackIndex, const char* name, bool loop);
spTrackEntry* addAnimation (int trackIndex, const char* name, bool loop, float delay = 0);
spTrackEntry* getCurrent (int trackIndex = 0);
void clearTracks ();
void clearTrack (int trackIndex = 0);
void onAnimationStateEvent (int trackIndex, EventType type, Event* event, int loopCount);
void onAnimationStateEvent (int trackIndex, spEventType type, spEvent* event, int loopCount);
protected:
CCSkeletonAnimation ();

10
spine-cocos2dx/src/spine/spine-cocos2dx.cpp
View File

@ -36,7 +36,7 @@
USING_NS_CC;
void _AtlasPage_createTexture (AtlasPage* self, const char* path) {
void _spAtlasPage_createTexture (spAtlasPage* self, const char* path) {
CCTexture2D* texture = CCTextureCache::sharedTextureCache()->addImage(path);
CCTextureAtlas* textureAtlas = CCTextureAtlas::createWithTexture(texture, 128);
textureAtlas->retain();
@ -45,11 +45,11 @@ void _AtlasPage_createTexture (AtlasPage* self, const char* path) {
self->height = texture->getPixelsHigh();
}
void _AtlasPage_disposeTexture (AtlasPage* self) {
void _spAtlasPage_disposeTexture (spAtlasPage* self) {
((CCTextureAtlas*)self->rendererObject)->release();
}
char* _Util_readFile (const char* path, int* length) {
char* _spUtil_readFile (const char* path, int* length) {
unsigned long size;
char* data = reinterpret_cast<char*>(CCFileUtils::sharedFileUtils()->getFileData(
CCFileUtils::sharedFileUtils()->fullPathForFilename(path).c_str(), "r", &size));
@ -59,9 +59,9 @@ char* _Util_readFile (const char* path, int* length) {
/**/
void RegionAttachment_updateQuad (RegionAttachment* self, Slot* slot, ccV3F_C4B_T2F_Quad* quad, bool premultipliedAlpha) {
void spRegionAttachment_updateQuad (spRegionAttachment* self, spSlot* slot, ccV3F_C4B_T2F_Quad* quad, bool premultipliedAlpha) {
float vertices[8];
RegionAttachment_computeWorldVertices(self, slot->skeleton->x, slot->skeleton->y, slot->bone, vertices);
spRegionAttachment_computeWorldVertices(self, slot->skeleton->x, slot->skeleton->y, slot->bone, vertices);
GLubyte r = slot->skeleton->r * slot->r * 255;
GLubyte g = slot->skeleton->g * slot->g * 255;

2
spine-cocos2dx/src/spine/spine-cocos2dx.h
View File

@ -39,6 +39,6 @@
#include <spine/CCSkeleton.h>
#include <spine/CCSkeletonAnimation.h>
void RegionAttachment_updateQuad (RegionAttachment* self, Slot* slot, cocos2d::ccV3F_C4B_T2F_Quad* quad, bool premultiplied = false);
void spRegionAttachment_updateQuad (spRegionAttachment* self, spSlot* slot, cocos2d::ccV3F_C4B_T2F_Quad* quad, bool premultiplied = false);
#endif /* SPINE_COCOS2DX_H_ */

1
spine-sfml/src/spine/spine-sfml.h
View File

@ -34,6 +34,7 @@
#ifndef SPINE_SFML_H_
#define SPINE_SFML_H_
#define SPINE_SHORT_NAMES
#include <spine/spine.h>
#include <SFML/Graphics/Vertex.hpp>
#include <SFML/Graphics/VertexArray.hpp>