diff --git a/spine-c/src/SfmlRegionAttachment.c b/spine-c/src/SfmlRegionAttachment.c index 82ca6f5ea..fdaafa721 100644 --- a/spine-c/src/SfmlRegionAttachment.c +++ b/spine-c/src/SfmlRegionAttachment.c @@ -1,14 +1,16 @@ #include "SfmlRegionAttachment.h" #include +void _RegionAttachment_init (RegionAttachment* attachment, const char* name); + void SfmlRegionAttachment_dispose (Attachment* attachment) { - SfmlRegionAttachment* this = (SfmlRegionAttachment*)attachment; - RegionAttachment_dispose(&this->super); + /* SfmlRegionAttachment* this = (SfmlRegionAttachment*)attachment; */ + /* dispose something */ } SfmlRegionAttachment* SfmlRegionAttachment_create (const char* name) { SfmlRegionAttachment* this = calloc(1, sizeof(SfmlRegionAttachment)); - RegionAttachment_init(&this->super, name); + _RegionAttachment_init(&this->super, name); ((Attachment*)this)->_dispose = SfmlRegionAttachment_dispose; return this; } diff --git a/spine-c/src/SfmlSkeleton.c b/spine-c/src/SfmlSkeleton.c index eb854a453..7223cedaa 100644 --- a/spine-c/src/SfmlSkeleton.c +++ b/spine-c/src/SfmlSkeleton.c @@ -1,13 +1,15 @@ #include "SfmlSkeleton.h" #include +void _Skeleton_init (Skeleton* this, SkeletonData* data); + void SfmlSkeleton_dispose (Skeleton* skeleton) { /* SfmlSkeleton* this = (SfmlSkeleton*)skeleton; */ } Skeleton* Skeleton_create (SkeletonData* data) { SfmlSkeleton* this = calloc(1, sizeof(SfmlSkeleton)); - Skeleton_init(&this->super, data); + _Skeleton_init(&this->super, data); this->super._dispose = SfmlSkeleton_dispose; return &this->super; } diff --git a/spine-c/src/spine/Animation.c b/spine-c/src/spine/Animation.c new file mode 100644 index 000000000..fc95d8a3c --- /dev/null +++ b/spine-c/src/spine/Animation.c @@ -0,0 +1,403 @@ +#include +#include + +Animation* Animation_create () { + Animation* this = calloc(1, sizeof(Animation)); + return this; +} + +void Animation_dispose (Animation* this) { + int i; + for (i = 0; i < this->timelineCount; ++i) + Timeline_dispose(this->timelines[i]); + FREE(this->timelines) + FREE(this) +} + +void Animation_apply (const Animation* animation, Skeleton* skeleton, float time, int/*bool*/loop) { +} + +void Animation_mix (const Animation* animation, Skeleton* skeleton, float time, int/*bool*/loop, float alpha) { +} + +/**/ + +void Timeline_dispose (Timeline* this) { + this->_dispose(this); +} + +void Timeline_apply (const Timeline *this, Skeleton* skeleton, float time, float alpha) { + this->_apply(this, skeleton, time, alpha); +} + +/**/ + +static const float CURVE_LINEAR = 0; +static const float CURVE_STEPPED = -1; +static const int CURVE_SEGMENTS = 10; + +void _CurveTimeline_init (CurveTimeline* this, int frameCount) { + this->curves = calloc(1, sizeof(float) * (frameCount - 1) * 6); +} + +void _CurveTimeline_deinit (CurveTimeline* this) { + FREE(this->curves) +} + +void CurveTimeline_setLinear (CurveTimeline* this, int frameIndex) { + this->curves[frameIndex * 6] = CURVE_LINEAR; +} + +void CurveTimeline_setStepped (CurveTimeline* this, int frameIndex) { + this->curves[frameIndex * 6] = CURVE_STEPPED; +} + +void CurveTimeline_setCurve (CurveTimeline* this, 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; + float pre1 = 3 * subdiv_step; + float pre2 = 3 * subdiv_step2; + float pre4 = 6 * subdiv_step2; + float pre5 = 6 * subdiv_step3; + float tmp1x = -cx1 * 2 + cx2; + float tmp1y = -cy1 * 2 + cy2; + float tmp2x = (cx1 - cx2) * 3 + 1; + float tmp2y = (cy1 - cy2) * 3 + 1; + int i = frameIndex * 6; + this->curves[i] = cx1 * pre1 + tmp1x * pre2 + tmp2x * subdiv_step3; + this->curves[i + 1] = cy1 * pre1 + tmp1y * pre2 + tmp2y * subdiv_step3; + this->curves[i + 2] = tmp1x * pre4 + tmp2x * pre5; + this->curves[i + 3] = tmp1y * pre4 + tmp2y * pre5; + this->curves[i + 4] = tmp2x * pre5; + this->curves[i + 5] = tmp2y * pre5; +} + +float CurveTimeline_getCurvePercent (CurveTimeline* this, int frameIndex, float percent) { + int curveIndex = frameIndex * 6; + float dfx = this->curves[curveIndex]; + if (dfx == CURVE_LINEAR) return percent; + if (dfx == CURVE_STEPPED) return 0; + float dfy = this->curves[curveIndex + 1]; + float ddfx = this->curves[curveIndex + 2]; + float ddfy = this->curves[curveIndex + 3]; + float dddfx = this->curves[curveIndex + 4]; + float dddfy = this->curves[curveIndex + 5]; + float x = dfx, y = dfy; + int i = CURVE_SEGMENTS - 2; + while (1) { + if (x >= percent) { + float lastX = x - dfx; + float lastY = y - dfy; + return lastY + (y - lastY) * (percent - lastX) / (x - lastX); + } + if (i == 0) break; + i--; + dfx += ddfx; + dfy += ddfy; + ddfx += dddfx; + ddfy += dddfy; + x += dfx; + y += dfy; + } + return y + (1 - y) * (percent - x) / (1 - x); /* Last point is 1,1. */ +} + +/** @param target After the first and before the last entry. */ +static int binarySearch (float *values, int valuesLength, float target, int step) { + int low = 0; + int high = valuesLength / step - 2; + if (high == 0) return step; + int current = high >> 1; + while (1) { + if (values[(current + 1) * step] <= target) + low = current + 1; + else + high = current; + if (low == high) return (low + 1) * step; + current = (low + high) >> 1; + } + return 0; +} + +/*static int linearSearch (float *values, int valuesLength, float target, int step) { + int i, last = valuesLength - step; + for (i = 0; i <= last; i += step) { + if (values[i] <= target) continue; + return i; + } + return -1; + }*/ + +/**/ + +void _BaseTimeline_dispose (Timeline* timeline) { + struct BaseTimeline* this = (struct BaseTimeline*)timeline; + _CurveTimeline_deinit(&this->super); + FREE(this->frames); + FREE(this); +} + +struct BaseTimeline* _BaseTimeline_create (int frameCount, int frameSize) { + struct BaseTimeline* this = calloc(1, sizeof(struct BaseTimeline)); + ((Timeline*)this)->_dispose = _BaseTimeline_dispose; + + CAST(int, this->frameCount) = frameCount; + CAST(float*, this->frames) = calloc(1, sizeof(float) * frameCount * frameSize); + + return this; +} + +/**/ + +static const int ROTATE_LAST_FRAME_TIME = -2; +static const int ROTATE_FRAME_VALUE = 1; + +void _RotateTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float time, float alpha) { + RotateTimeline* this = (RotateTimeline*)timeline; + + if (time < this->frames[0]) return; /* Time is before first frame. */ + + Bone *bone = skeleton->bones[this->boneIndex]; + + if (time >= this->frames[this->frameCount - 2]) { /* Time is after last frame. */ + float amount = bone->data->rotation + this->frames[this->frameCount - 1] - bone->rotation; + while (amount > 180) + amount -= 360; + while (amount < -180) + amount += 360; + bone->rotation += amount * alpha; + return; + } + + /* Interpolate between the last frame and the current frame. */ + int frameIndex = binarySearch(this->frames, this->frameCount, time, 2); + float lastFrameValue = this->frames[frameIndex - 1]; + float frameTime = this->frames[frameIndex]; + float percent = 1 - (time - frameTime) / (this->frames[frameIndex + ROTATE_LAST_FRAME_TIME] - frameTime); + percent = CurveTimeline_getCurvePercent(&this->super, frameIndex / 2 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent)); + + float amount = this->frames[frameIndex + ROTATE_FRAME_VALUE] - lastFrameValue; + while (amount > 180) + amount -= 360; + while (amount < -180) + amount += 360; + amount = bone->data->rotation + (lastFrameValue + amount * percent) - bone->rotation; + while (amount > 180) + amount -= 360; + while (amount < -180) + amount += 360; + bone->rotation += amount * alpha; +} + +RotateTimeline* RotateTimeline_create (int frameCount) { + RotateTimeline* this = _BaseTimeline_create(frameCount, 2); + ((Timeline*)this)->_apply = _RotateTimeline_apply; + _CurveTimeline_init(&this->super, frameCount); + return this; +} + +void RotateTimeline_setFrame (RotateTimeline* this, int frameIndex, float time, float angle) { + frameIndex *= 2; + this->frames[frameIndex] = time; + this->frames[frameIndex + 1] = angle; +} + +/**/ + +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 time, float alpha) { + TranslateTimeline* this = (TranslateTimeline*)timeline; + + if (time < this->frames[0]) return; /* Time is before first frame. */ + + Bone *bone = skeleton->bones[this->boneIndex]; + + if (time >= this->frames[this->frameCount - 3]) { /* Time is after last frame. */ + bone->x += (bone->data->x + this->frames[this->frameCount - 2] - bone->x) * alpha; + bone->y += (bone->data->y + this->frames[this->frameCount - 1] - bone->y) * alpha; + return; + } + + /* Interpolate between the last frame and the current frame. */ + int frameIndex = binarySearch(this->frames, this->frameCount, time, 3); + float lastFrameX = this->frames[frameIndex - 2]; + float lastFrameY = this->frames[frameIndex - 1]; + float frameTime = this->frames[frameIndex]; + float percent = 1 - (time - frameTime) / (this->frames[frameIndex + TRANSLATE_LAST_FRAME_TIME] - frameTime); + percent = CurveTimeline_getCurvePercent(&this->super, frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent)); + + bone->x += (bone->data->x + lastFrameX + (this->frames[frameIndex + TRANSLATE_FRAME_X] - lastFrameX) * percent - bone->x) + * alpha; + bone->y += (bone->data->y + lastFrameY + (this->frames[frameIndex + TRANSLATE_FRAME_Y] - lastFrameY) * percent - bone->y) + * alpha; +} + +TranslateTimeline* TranslateTimeline_create (int frameCount) { + TranslateTimeline* this = _BaseTimeline_create(frameCount, 3); + ((Timeline*)this)->_apply = _TranslateTimeline_apply; + _CurveTimeline_init(&this->super, frameCount); + return this; +} + +void TranslateTimeline_setFrame (TranslateTimeline* this, int frameIndex, float time, float x, float y) { + frameIndex *= 3; + this->frames[frameIndex] = time; + this->frames[frameIndex + 1] = x; + this->frames[frameIndex + 2] = y; +} + +/**/ + +void _ScaleTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float time, float alpha) { + ScaleTimeline* this = (ScaleTimeline*)timeline; + + if (time < this->frames[0]) return; /* Time is before first frame. */ + + Bone *bone = skeleton->bones[this->boneIndex]; + if (time >= this->frames[this->frameCount - 3]) { /* Time is after last frame. */ + bone->scaleX += (bone->data->scaleX - 1 + this->frames[this->frameCount - 2] - bone->scaleX) * alpha; + bone->scaleY += (bone->data->scaleY - 1 + this->frames[this->frameCount - 1] - bone->scaleY) * alpha; + return; + } + + /* Interpolate between the last frame and the current frame. */ + int frameIndex = binarySearch(this->frames, this->frameCount, time, 3); + float lastFrameX = this->frames[frameIndex - 2]; + float lastFrameY = this->frames[frameIndex - 1]; + float frameTime = this->frames[frameIndex]; + float percent = 1 - (time - frameTime) / (this->frames[frameIndex + TRANSLATE_LAST_FRAME_TIME] - frameTime); + percent = CurveTimeline_getCurvePercent(&this->super, frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent)); + + bone->scaleX += (bone->data->scaleX - 1 + lastFrameX + (this->frames[frameIndex + TRANSLATE_FRAME_X] - lastFrameX) * percent + - bone->scaleX) * alpha; + bone->scaleY += (bone->data->scaleY - 1 + lastFrameY + (this->frames[frameIndex + TRANSLATE_FRAME_Y] - lastFrameY) * percent + - bone->scaleY) * alpha; +} + +ScaleTimeline* ScaleTimeline_create (int frameCount) { + ScaleTimeline* this = _BaseTimeline_create(frameCount, 3); + ((Timeline*)this)->_apply = _ScaleTimeline_apply; + _CurveTimeline_init(&this->super, frameCount); + return this; +} + +void ScaleTimeline_setFrame (ScaleTimeline* this, int frameIndex, float time, float x, float y) { + TranslateTimeline_setFrame(this, frameIndex, time, x, y); +} + +/**/ + +static const int COLOR_LAST_FRAME_TIME = -5; +static const int COLOR_FRAME_R = 1; +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 time, float alpha) { + ColorTimeline* this = (ColorTimeline*)timeline; + + if (time < this->frames[0]) return; /* Time is before first frame. */ + + Slot *slot = skeleton->slots[this->slotIndex]; + + if (time >= this->frames[this->frameCount - 5]) { /* Time is after last frame. */ + int i = this->frameCount - 1; + slot->r = this->frames[i - 3]; + slot->g = this->frames[i - 2]; + slot->b = this->frames[i - 1]; + slot->a = this->frames[i]; + return; + } + + /* Interpolate between the last frame and the current frame. */ + int frameIndex = binarySearch(this->frames, this->frameCount, time, 5); + float lastFrameR = this->frames[frameIndex - 4]; + float lastFrameG = this->frames[frameIndex - 3]; + float lastFrameB = this->frames[frameIndex - 2]; + float lastFrameA = this->frames[frameIndex - 1]; + float frameTime = this->frames[frameIndex]; + float percent = 1 - (time - frameTime) / (this->frames[frameIndex + COLOR_LAST_FRAME_TIME] - frameTime); + percent = CurveTimeline_getCurvePercent(&this->super, frameIndex / 5 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent)); + + float r = lastFrameR + (this->frames[frameIndex + COLOR_FRAME_R] - lastFrameR) * percent; + float g = lastFrameG + (this->frames[frameIndex + COLOR_FRAME_G] - lastFrameG) * percent; + float b = lastFrameB + (this->frames[frameIndex + COLOR_FRAME_B] - lastFrameB) * percent; + float a = lastFrameA + (this->frames[frameIndex + COLOR_FRAME_A] - lastFrameA) * percent; + if (alpha < 1) { + slot->r += (r - slot->r) * alpha; + slot->g += (g - slot->g) * alpha; + slot->b += (b - slot->b) * alpha; + slot->a += (a - slot->a) * alpha; + } else { + slot->r = r; + slot->g = g; + slot->b = b; + slot->a = a; + } +} + +ColorTimeline* ColorTimeline_create (int frameCount) { + ColorTimeline* this = (ColorTimeline*)_BaseTimeline_create(frameCount, 5); + ((Timeline*)this)->_apply = _ColorTimeline_apply; + _CurveTimeline_init(&this->super, frameCount); + return this; +} + +void ColorTimeline_setFrame (ColorTimeline* this, int frameIndex, float time, float r, float g, float b, float a) { + frameIndex *= 5; + this->frames[frameIndex] = time; + this->frames[frameIndex + 1] = r; + this->frames[frameIndex + 2] = g; + this->frames[frameIndex + 3] = b; + this->frames[frameIndex + 4] = a; +} + +/**/ + +void _AttachmentTimeline_apply (const Timeline* timeline, Skeleton* skeleton, float time, float alpha) { + AttachmentTimeline* this = (AttachmentTimeline*)timeline; + + if (time < this->frames[0]) return; /* Time is before first frame. */ + + int frameIndex; + if (time >= this->frames[this->frameCount - 1]) /* Time is after last frame. */ + frameIndex = this->frameCount - 1; + else + frameIndex = binarySearch(this->frames, this->frameCount, time, 1) - 1; + + const char* attachmentName = this->attachmentNames[frameIndex]; + Slot_setAttachment(skeleton->slots[this->slotIndex], + attachmentName ? Skeleton_getAttachmentForSlotIndex(skeleton, this->slotIndex, attachmentName) : 0); +} + +void _AttachmentTimeline_dispose (Timeline* timeline) { + AttachmentTimeline* this = (AttachmentTimeline*)timeline; + + int i; + for (i = 0; i < this->frameCount; ++i) + FREE(this->attachmentNames[i]) + FREE(this->attachmentNames) + + _BaseTimeline_dispose(timeline); +} + +AttachmentTimeline* AttachmentTimeline_create (int frameCount) { + AttachmentTimeline* this = (AttachmentTimeline*)_BaseTimeline_create(frameCount, 1); + ((Timeline*)this)->_dispose = _AttachmentTimeline_dispose; + ((Timeline*)this)->_apply = _AttachmentTimeline_apply; + CAST(char*, this->attachmentNames) = calloc(1, sizeof(char*) * frameCount); + return this; +} + +void AttachmentTimeline_setFrame (AttachmentTimeline* this, int frameIndex, float time, const char* attachmentName) { + this->frames[frameIndex] = time; + FREE(this->attachmentNames[frameIndex]) + if (attachmentName) + MALLOC_STR(this->attachmentNames[frameIndex], attachmentName) + else + this->attachmentNames[frameIndex] = 0; +} diff --git a/spine-c/src/spine/Animation.h b/spine-c/src/spine/Animation.h new file mode 100644 index 000000000..a59167a6c --- /dev/null +++ b/spine-c/src/spine/Animation.h @@ -0,0 +1,114 @@ +#ifndef SPINE_ANIMATION_H_ +#define SPINE_ANIMATION_H_ + +#include + +#ifdef __cplusplus +namespace spine { +extern "C" { +#endif + +typedef struct Timeline Timeline; + +typedef struct { + int timelineCount; + Timeline** timelines; + + float duration; +} Animation; + +Animation* Animation_create (); +void Animation_dispose (Animation* animation); + +void Animation_apply (const Animation* animation, Skeleton* skeleton, float time, int/*bool*/loop); +void Animation_mix (const Animation* animation, Skeleton* skeleton, float time, int/*bool*/loop, float alpha); + +/**/ + +struct Timeline { + void (*_apply) (const Timeline* timeline, Skeleton* skeleton, float time, float alpha); + void (*_dispose) (Timeline* timeline); +}; + +void Timeline_dispose (Timeline* timeline); +void Timeline_apply (const Timeline* timeline, Skeleton* skeleton, float time, float alpha); + +/**/ + +typedef struct { + Timeline super; + float* curves; /* dfx, dfy, ddfx, ddfy, dddfx, dddfy, ... */ +} CurveTimeline; + +void CurveTimeline_setLinear (CurveTimeline* timeline, int frameIndex); +void CurveTimeline_setStepped (CurveTimeline* timeline, 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* timeline, int frameIndex, float cx1, float cy1, float cx2, float cy2); +float CurveTimeline_getCurvePercent (CurveTimeline* timeline, int frameIndex, float percent); + +/**/ + +typedef struct BaseTimeline { + CurveTimeline super; + int const frameCount; + float* const frames; /* time, angle, ... for rotate. time, x, y, ... for translate and scale. */ + int boneIndex; +} RotateTimeline; + +RotateTimeline* RotateTimeline_create (int frameCount); + +void RotateTimeline_setFrame (RotateTimeline* timeline, int frameIndex, float time, float angle); + +/**/ + +typedef struct BaseTimeline TranslateTimeline; + +TranslateTimeline* TranslateTimeline_create (int frameCount); + +void TranslateTimeline_setFrame (TranslateTimeline* timeline, int frameIndex, float time, float x, float y); + +/**/ + +typedef struct BaseTimeline ScaleTimeline; + +ScaleTimeline* ScaleTimeline_create (int frameCount); + +void ScaleTimeline_setFrame (ScaleTimeline* timeline, int frameIndex, float time, float x, float y); + +/**/ + +typedef struct { + CurveTimeline super; + int const frameCount; + float* const frames; /* time, r, g, b, a, ... */ + int slotIndex; +} ColorTimeline; + +ColorTimeline* ColorTimeline_create (int frameCount); + +void ColorTimeline_setFrame (ColorTimeline* timeline, int frameIndex, float time, float r, float g, float b, float a); + +/**/ + +typedef struct { + Timeline super; + int const frameCount; + float* const frames; /* time, ... */ + int slotIndex; + const char** const attachmentNames; +} AttachmentTimeline; + +AttachmentTimeline* AttachmentTimeline_create (int frameCount); + +/** @param attachmentName May be 0. */ +void AttachmentTimeline_setFrame (AttachmentTimeline* timeline, int frameIndex, float time, const char* attachmentName); + +#ifdef __cplusplus +} +} +#endif + +#endif /* SPINE_ANIMATION_H_ */ diff --git a/spine-c/src/spine/Atlas.c b/spine-c/src/spine/Atlas.c index ce490d82c..490dcd7c7 100644 --- a/spine-c/src/spine/Atlas.c +++ b/spine-c/src/spine/Atlas.c @@ -7,6 +7,12 @@ AtlasPage* AtlasPage_create () { return this; } +void AtlasPage_dispose (AtlasPage* this) { + if (this->next) AtlasPage_dispose(this->next); + FREE(this->name); + FREE(this); +} + /**/ AtlasRegion* AtlasRegion_create () { @@ -14,6 +20,14 @@ AtlasRegion* AtlasRegion_create () { return this; } +void AtlasRegion_dispose (AtlasRegion* this) { + if (this->next) AtlasRegion_dispose(this->next); + FREE(this->name); + FREE(this->splits); + FREE(this->pads); + FREE(this); +} + /**/ typedef struct { @@ -80,7 +94,7 @@ static int readTuple (Str tuple[]) { readLine(0, &str); if (!beginPast(&str, ':')) return 0; int i = 0; - for (i = 0; i < 3; i++) { + for (i = 0; i < 3; ++i) { tuple[i].begin = str.begin; if (!beginPast(&str, ',')) { if (i == 0) return 0; @@ -224,9 +238,16 @@ Atlas* Atlas_readAtlasFile (const char* path) { } void Atlas_dispose (Atlas* this) { + if (this->pages) AtlasPage_dispose(this->pages); + if (this->regions) AtlasRegion_dispose(this->regions); FREE(this) } -AtlasRegion* Atlas_findRegion (Atlas* atlas, const char* name) { +AtlasRegion* Atlas_findRegion (const Atlas* this, const char* name) { + AtlasRegion* region = this->regions; + while (region) { + if (strcmp(region->name, name) == 0) return region; + region = region->next; + } return 0; } diff --git a/spine-c/src/spine/Atlas.h b/spine-c/src/spine/Atlas.h index d4e21a2bc..1e9089e71 100644 --- a/spine-c/src/spine/Atlas.h +++ b/spine-c/src/spine/Atlas.h @@ -57,7 +57,7 @@ Atlas* Atlas_readAtlas (const char* data); Atlas* Atlas_readAtlasFile (const char* path); void Atlas_dispose (Atlas* atlas); -AtlasRegion* Atlas_findRegion (Atlas* atlas, const char* name); +AtlasRegion* Atlas_findRegion (const Atlas* atlas, const char* name); #ifdef __cplusplus } diff --git a/spine-c/src/spine/Attachment.h b/spine-c/src/spine/Attachment.h index 9b7957689..5cf5322ce 100644 --- a/spine-c/src/spine/Attachment.h +++ b/spine-c/src/spine/Attachment.h @@ -13,6 +13,7 @@ typedef enum { typedef struct Attachment Attachment; struct Attachment { const char* const name; + void (*_dispose) (Attachment* attachment); }; diff --git a/spine-c/src/spine/Bone.c b/spine-c/src/spine/Bone.c index 30fb73d3d..228ac8bda 100644 --- a/spine-c/src/spine/Bone.c +++ b/spine-c/src/spine/Bone.c @@ -44,12 +44,12 @@ void Bone_updateWorldTransform (Bone* this, int flipX, int flipY) { CAST(float, this->worldRotation) = this->rotation; } float radians = (float)(this->worldRotation * 3.1415926535897932385 / 180); - float cos = cosf(radians); - float sin = sinf(radians); - CAST(float, this->m00) = cos * this->worldScaleX; - CAST(float, this->m10) = sin * this->worldScaleX; - CAST(float, this->m01) = -sin * this->worldScaleY; - CAST(float, this->m11) = cos * this->worldScaleY; + float cosine = cos(radians); + float sine = sin(radians); + CAST(float, this->m00) = cosine * this->worldScaleX; + CAST(float, this->m10) = sine * this->worldScaleX; + CAST(float, this->m01) = -sine * this->worldScaleY; + CAST(float, this->m11) = cosine * this->worldScaleY; if (flipX) { CAST(float, this->m00) = -this->m00; CAST(float, this->m01) = -this->m01; diff --git a/spine-c/src/spine/RegionAttachment.c b/spine-c/src/spine/RegionAttachment.c index 47b380cf2..79ff08ca8 100644 --- a/spine-c/src/spine/RegionAttachment.c +++ b/spine-c/src/spine/RegionAttachment.c @@ -2,16 +2,12 @@ #include #include -void RegionAttachment_init (RegionAttachment* this, const char* name) { +void _RegionAttachment_init (RegionAttachment* this, const char* name) { Attachment_init(&this->super, name); this->scaleX = 1; this->scaleY = 1; } -void RegionAttachment_dispose (RegionAttachment* this) { - Attachment_dispose(&this->super); -} - void RegionAttachment_updateOffset (RegionAttachment* this) { float localX2 = this->width / 2; float localY2 = this->height / 2; diff --git a/spine-c/src/spine/RegionAttachment.h b/spine-c/src/spine/RegionAttachment.h index ff37347a7..fb2347a02 100644 --- a/spine-c/src/spine/RegionAttachment.h +++ b/spine-c/src/spine/RegionAttachment.h @@ -15,9 +15,6 @@ struct RegionAttachment { float offset[8]; }; -void RegionAttachment_init (RegionAttachment* attachment, const char* name); -void RegionAttachment_dispose (RegionAttachment* attachment); - void RegionAttachment_updateOffset (RegionAttachment* attachment); #ifdef __cplusplus diff --git a/spine-c/src/spine/Skeleton.c b/spine-c/src/spine/Skeleton.c index 66ef9b960..527240071 100644 --- a/spine-c/src/spine/Skeleton.c +++ b/spine-c/src/spine/Skeleton.c @@ -1,7 +1,7 @@ #include #include -void Skeleton_init (Skeleton* this, SkeletonData* data) { +void _Skeleton_init (Skeleton* this, SkeletonData* data) { CAST(SkeletonData*, this->data) = data; this->boneCount = this->data->boneCount; @@ -51,9 +51,9 @@ void Skeleton_dispose (Skeleton* this) { Bone_dispose(this->bones[i]); FREE(this->bones) - FREE(this->slots) for (i = 0; i < this->slotCount; ++i) Slot_dispose(this->slots[i]); + FREE(this->slots) FREE(this->drawOrder) diff --git a/spine-c/src/spine/Skeleton.h b/spine-c/src/spine/Skeleton.h index 8e81e9416..269bd9aa3 100644 --- a/spine-c/src/spine/Skeleton.h +++ b/spine-c/src/spine/Skeleton.h @@ -29,7 +29,6 @@ struct Skeleton { void (*_dispose) (Skeleton* skeleton); }; -void Skeleton_init (Skeleton* skeleton, SkeletonData* data); void Skeleton_dispose (Skeleton* skeleton); void Skeleton_updateWorldTransform (const Skeleton* skeleton); diff --git a/spine-c/src/spine/Skin.c b/spine-c/src/spine/Skin.c index f4b84c503..bc2605928 100644 --- a/spine-c/src/spine/Skin.c +++ b/spine-c/src/spine/Skin.c @@ -1,19 +1,19 @@ #include #include -SkinEntry* SkinEntry_create (int slotIndex, const char* name, Attachment* attachment) { - SkinEntry* entry = calloc(1, sizeof(SkinEntry)); - entry->slotIndex = slotIndex; - MALLOC_STR(entry->name, name) - entry->attachment = attachment; - return entry; +SkinEntry* _SkinEntry_create (int slotIndex, const char* name, Attachment* attachment) { + SkinEntry* this = calloc(1, sizeof(SkinEntry)); + this->slotIndex = slotIndex; + MALLOC_STR(this->name, name) + this->attachment = attachment; + return this; } -void SkinEntry_dispose (SkinEntry* entry) { - if (entry->next) SkinEntry_dispose((SkinEntry*)entry->next); - Attachment_dispose(entry->attachment); - FREE(entry->name) - FREE(entry) +void _SkinEntry_dispose (SkinEntry* this) { + if (this->next) _SkinEntry_dispose((SkinEntry*)this->next); + Attachment_dispose(this->attachment); + FREE(this->name) + FREE(this) } /**/ @@ -25,13 +25,13 @@ Skin* Skin_create (const char* name) { } void Skin_dispose (Skin* this) { - SkinEntry_dispose((SkinEntry*)this->entries); + _SkinEntry_dispose((SkinEntry*)this->entries); FREE(this->name) FREE(this) } void Skin_addAttachment (Skin* this, int slotIndex, const char* name, Attachment* attachment) { - SkinEntry* newEntry = SkinEntry_create(slotIndex, name, attachment); + SkinEntry* newEntry = _SkinEntry_create(slotIndex, name, attachment); SkinEntry* entry = (SkinEntry*)this->entries; if (!entry) entry = newEntry;