diff --git a/spine-c/.cproject b/spine-c/.cproject
index c6d57c96e..cafccbcb6 100644
--- a/spine-c/.cproject
+++ b/spine-c/.cproject
@@ -35,6 +35,7 @@
+
diff --git a/spine-c/src/SfmlSkeleton.c b/spine-c/src/SfmlSkeleton.c
index 6663c5934..eb854a453 100644
--- a/spine-c/src/SfmlSkeleton.c
+++ b/spine-c/src/SfmlSkeleton.c
@@ -2,7 +2,7 @@
#include
void SfmlSkeleton_dispose (Skeleton* skeleton) {
- // SfmlSkeleton* this = (SfmlSkeleton*)skeleton;
+ /* SfmlSkeleton* this = (SfmlSkeleton*)skeleton; */
}
Skeleton* Skeleton_create (SkeletonData* data) {
diff --git a/spine-c/src/main.c b/spine-c/src/main.c
index c3efaa9f5..c1c9184a7 100644
--- a/spine-c/src/main.c
+++ b/spine-c/src/main.c
@@ -4,24 +4,27 @@
#include
#include "SfmlSkeleton.h"
+#include "SfmlRegionAttachment.h"
#include "spine/cJSON.h"
+Attachment* loadAttachment (AttachmentType type, const char* name) {
+ return (Attachment*)SfmlRegionAttachment_create(name);
+}
+
int main (void) {
- //BoneData *boneData = BoneData_create("meow");
+ Attachment_setAttachmentLoader(loadAttachment);
- //printf("name: %s\n", boneData->name);
- //printf("length struct: %f\n", boneData->length);
-
- //SkeletonData* data =
SkeletonJson_readSkeletonDataFile("data/spineboy-skeleton.json");
- printf("error: %s\n", SkeletonJson_getError());
+ if (SkeletonJson_getError()) printf("error: %s\n", SkeletonJson_getError());
SkeletonData *skeletonData = SkeletonData_create();
Skeleton* skeleton = Skeleton_create(skeletonData);
- //Skeleton_something(skeleton);
printf("meow? %d\n", ((SfmlSkeleton*)skeleton)->meow);
Skeleton_dispose(skeleton);
printf("meow? %d\n", ((SfmlSkeleton*)skeleton)->meow);
+ Atlas* atlas = Atlas_readAtlasFile("data/spineboy.atlas");
+ printf("%s %d", atlas->regions->name, atlas->regions->y);
+
return 0;
}
diff --git a/spine-c/src/spine/Atlas.c b/spine-c/src/spine/Atlas.c
new file mode 100644
index 000000000..ce490d82c
--- /dev/null
+++ b/spine-c/src/spine/Atlas.c
@@ -0,0 +1,232 @@
+#include
+#include
+#include
+
+AtlasPage* AtlasPage_create () {
+ AtlasPage* this = calloc(1, sizeof(AtlasPage));
+ return this;
+}
+
+/**/
+
+AtlasRegion* AtlasRegion_create () {
+ AtlasRegion* this = calloc(1, sizeof(AtlasRegion));
+ return this;
+}
+
+/**/
+
+typedef struct {
+ const char* begin;
+ const char* end;
+} Str;
+
+static void trim (Str* str) {
+ while (isspace(*str->begin) && str->begin < str->end)
+ (str->begin)++;
+ if (str->begin == str->end) return;
+ str->end--;
+ while (isspace(*str->end) && str->end >= str->begin)
+ str->end--;
+ str->end++;
+}
+
+/** Tokenize string without modification. Returns 0 on failure. */
+static int readLine (const char* data, Str* str) {
+ static const char* nextStart;
+ if (data) {
+ nextStart = data;
+ return 1;
+ }
+ if (*nextStart == '\0') return 0;
+ str->begin = nextStart;
+
+ /* Find next delimiter. */
+ do {
+ nextStart++;
+ } while (*nextStart != '\0' && *nextStart != '\n');
+
+ str->end = nextStart;
+ trim(str);
+
+ if (*nextStart != '\0') nextStart++;
+ return 1;
+}
+
+/** Moves str->begin past the first occurence of c. Returns 0 on failure. */
+static int beginPast (Str* str, char c) {
+ const char* begin = str->begin;
+ while (1) {
+ char lastSkippedChar = *begin;
+ if (begin == str->end) return 0;
+ begin++;
+ if (lastSkippedChar == c) break;
+ }
+ str->begin = begin;
+ return 1;
+}
+
+/* Returns 0 on failure. */
+static int readValue (Str* str) {
+ readLine(0, str);
+ if (!beginPast(str, ':')) return 0;
+ trim(str);
+ return 1;
+}
+
+/** Returns the number of tuple values read (2, 4, or 0 for failure). */
+static int readTuple (Str tuple[]) {
+ Str str;
+ readLine(0, &str);
+ if (!beginPast(&str, ':')) return 0;
+ int i = 0;
+ for (i = 0; i < 3; i++) {
+ tuple[i].begin = str.begin;
+ if (!beginPast(&str, ',')) {
+ if (i == 0) return 0;
+ break;
+ }
+ tuple[i].end = str.begin - 2;
+ trim(&tuple[i]);
+ }
+ tuple[i].begin = str.begin;
+ tuple[i].end = str.end;
+ trim(&tuple[i]);
+ return i + 1;
+}
+
+static char* mallocString (Str* str) {
+ int length = str->end - str->begin;
+ char* string = malloc(length + 1);
+ memcpy(string, str->begin, length);
+ string[length] = '\0';
+ return string;
+}
+
+static int indexOf (const char** array, int count, Str* str) {
+ int length = str->end - str->begin;
+ int i;
+ for (i = count - 1; i >= 0; i--)
+ if (strncmp(array[i], str->begin, length) == 0) return i;
+ return -1;
+}
+
+static int equals (Str* str, char* other) {
+ return strncmp(other, str->begin, str->end - str->begin) == 0;
+}
+
+static int toInt (Str* str) {
+ return strtol(str->begin, (char**)&str->end, 10);
+}
+
+static const char* formatNames[] = {"Alpha", "Intensity", "LuminanceAlpha", "RGB565", "RGBA4444", "RGB888", "RGBA8888"};
+static const char* textureFilterNames[] = {"Nearest", "Linear", "MipMap", "MipMapNearestNearest", "MipMapLinearNearest",
+ "MipMapNearestLinear", "MipMapLinearLinear"};
+
+Atlas* Atlas_readAtlas (const char* data) {
+ Atlas* this = calloc(1, sizeof(Atlas));
+
+ AtlasPage *page = 0;
+ AtlasPage *lastPage = 0;
+ AtlasRegion *lastRegion = 0;
+ Str str;
+ Str tuple[4];
+ readLine(data, 0);
+ while (readLine(0, &str)) {
+ if (str.end - str.begin == 0) {
+ page = 0;
+ } else if (!page) {
+ page = AtlasPage_create();
+ if (lastPage)
+ lastPage->next = page;
+ else
+ this->pages = page;
+ lastPage = page;
+
+ page->name = mallocString(&str);
+
+ if (!readValue(&str)) return 0;
+ page->format = (AtlasFormat)indexOf(formatNames, 7, &str);
+
+ if (!readTuple(tuple)) return 0;
+ page->minFilter = (AtlasFilter)indexOf(textureFilterNames, 7, tuple);
+ page->magFilter = (AtlasFilter)indexOf(textureFilterNames, 7, tuple + 1);
+
+ if (!readValue(&str)) return 0;
+ if (!equals(&str, "none")) {
+ page->uWrap = *str.begin == 'x' ? ATLAS_REPEAT : (*str.begin == 'y' ? ATLAS_CLAMPTOEDGE : ATLAS_REPEAT);
+ page->vWrap = *str.begin == 'x' ? ATLAS_CLAMPTOEDGE : (*str.begin == 'y' ? ATLAS_REPEAT : ATLAS_REPEAT);
+ }
+ } else {
+ AtlasRegion *region = AtlasRegion_create();
+ if (lastRegion)
+ lastRegion->next = region;
+ else
+ this->regions = region;
+ lastRegion = region;
+
+ region->page = page;
+ region->name = mallocString(&str);
+
+ if (!readValue(&str)) return 0;
+ region->rotate = equals(&str, "true");
+
+ if (readTuple(tuple) != 2) return 0;
+ region->x = toInt(tuple);
+ region->y = toInt(tuple + 1);
+
+ if (readTuple(tuple) != 2) return 0;
+ region->width = toInt(tuple);
+ region->height = toInt(tuple + 1);
+
+ int count;
+ if (!(count = readTuple(tuple))) return 0;
+ if (count == 4) { /* split is optional */
+ region->splits = malloc(sizeof(int) * 4);
+ region->splits[0] = toInt(tuple);
+ region->splits[1] = toInt(tuple + 1);
+ region->splits[2] = toInt(tuple + 2);
+ region->splits[3] = toInt(tuple + 3);
+
+ if (!(count = readTuple(tuple))) return 0;
+ if (count == 4) { /* pad is optional, but only present with splits */
+ region->pads = malloc(sizeof(int) * 4);
+ region->pads[0] = toInt(tuple);
+ region->pads[1] = toInt(tuple + 1);
+ region->pads[2] = toInt(tuple + 2);
+ region->pads[3] = toInt(tuple + 3);
+
+ if (!readTuple(tuple)) return 0;
+ }
+ }
+
+ region->originalWidth = toInt(tuple);
+ region->originalHeight = toInt(tuple + 1);
+
+ readTuple(tuple);
+ region->offsetX = (float)toInt(tuple);
+ region->offsetY = (float)toInt(tuple + 1);
+
+ if (!readValue(&str)) return 0;
+ region->index = toInt(&str);
+ }
+ }
+
+ return this;
+}
+
+Atlas* Atlas_readAtlasFile (const char* path) {
+ const char* data = readFile(path);
+ if (!data) return 0;
+ Atlas* atlas = Atlas_readAtlas(data);
+ FREE(data)
+ return atlas;
+}
+
+void Atlas_dispose (Atlas* this) {
+ FREE(this)
+}
+
+AtlasRegion* Atlas_findRegion (Atlas* atlas, const char* name) {
+ return 0;
+}
diff --git a/spine-c/src/spine/Atlas.h b/spine-c/src/spine/Atlas.h
new file mode 100644
index 000000000..d4e21a2bc
--- /dev/null
+++ b/spine-c/src/spine/Atlas.h
@@ -0,0 +1,67 @@
+#ifndef SPINE_ATLAS_H_
+#define SPINE_ATLAS_H_
+
+#ifdef __cplusplus
+namespace spine {
+extern "C" {
+#endif
+
+typedef enum {
+ ATLAS_ALPHA, ATLAS_INTENSITY, ATLAS_LUMINANCEALPHA, ATLAS_RGB565, ATLAS_RGBA4444, ATLAS_RGB888, ATLAS_RGBA8888
+} AtlasFormat;
+
+typedef enum {
+ ATLAS_NEAREST,
+ ATLAS_LINEAR,
+ ATLAS_MIPMAP,
+ ATLAS_MIPMAPNEARESTNEAREST,
+ ATLAS_MIPMAPLINEARNEAREST,
+ ATLAS_MIPMAPNEARESTLINEAR,
+ ATLAS_MIPMAPLINEARLINEAR
+} AtlasFilter;
+
+typedef enum {
+ ATLAS_MIRROREDREPEAT, ATLAS_CLAMPTOEDGE, ATLAS_REPEAT
+} AtlasWrap;
+
+typedef struct AtlasPage AtlasPage;
+struct AtlasPage {
+ const char* name;
+ AtlasFormat format;
+ AtlasFilter minFilter, magFilter;
+ AtlasWrap uWrap, vWrap;
+ AtlasPage* next;
+};
+
+typedef struct AtlasRegion AtlasRegion;
+struct AtlasRegion {
+ const char* name;
+ int x, y, width, height;
+ float offsetX, offsetY;
+ int originalWidth, originalHeight;
+ int index;
+ int/*bool*/rotate;
+ int/*bool*/flip;
+ int* splits;
+ int* pads;
+ AtlasPage* page;
+ AtlasRegion* next;
+};
+
+typedef struct {
+ AtlasPage* pages;
+ AtlasRegion* regions;
+} Atlas;
+
+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);
+
+#ifdef __cplusplus
+}
+}
+#endif
+
+#endif /* SPINE_ATLAS_H_ */
diff --git a/spine-c/src/spine/Bone.h b/spine-c/src/spine/Bone.h
index 2cac45d29..71cf744a8 100644
--- a/spine-c/src/spine/Bone.h
+++ b/spine-c/src/spine/Bone.h
@@ -16,13 +16,13 @@ struct Bone {
float rotation;
float scaleX, scaleY;
- float const m00, m01, worldX; // a b x
- float const m10, m11, worldY; // c d y
+ float const m00, m01, worldX; /* a b x */
+ float const m10, m11, worldY; /* c d y */
float const worldRotation;
float const worldScaleX, worldScaleY;
};
-void Bone_setYDown (int yDown);
+void Bone_setYDown (int/*bool*/yDown);
/** @param parent May be zero. */
Bone* Bone_create (BoneData* data, Bone* parent);
@@ -30,7 +30,7 @@ void Bone_dispose (Bone* bone);
void Bone_setToBindPose (Bone* bone);
-void Bone_updateWorldTransform (Bone* bone, int flipX, int flipY);
+void Bone_updateWorldTransform (Bone* bone, int/*bool*/flipX, int/*bool*/flipY);
#ifdef __cplusplus
}
diff --git a/spine-c/src/spine/RegionAttachment.h b/spine-c/src/spine/RegionAttachment.h
index 1d758b359..ff37347a7 100644
--- a/spine-c/src/spine/RegionAttachment.h
+++ b/spine-c/src/spine/RegionAttachment.h
@@ -15,7 +15,7 @@ struct RegionAttachment {
float offset[8];
};
-void RegionAttachment_init (RegionAttachment* this, const char* name);
+void RegionAttachment_init (RegionAttachment* attachment, const char* name);
void RegionAttachment_dispose (RegionAttachment* attachment);
void RegionAttachment_updateOffset (RegionAttachment* attachment);
diff --git a/spine-c/src/spine/Skeleton.c b/spine-c/src/spine/Skeleton.c
index 6c527d5c2..66ef9b960 100644
--- a/spine-c/src/spine/Skeleton.c
+++ b/spine-c/src/spine/Skeleton.c
@@ -11,7 +11,7 @@ void Skeleton_init (Skeleton* this, SkeletonData* data) {
BoneData* boneData = this->data->bones[i];
Bone* parent = 0;
if (boneData->parent) {
- // Find parent bone.
+ /* Find parent bone. */
for (ii = 0; ii < this->boneCount; ++ii) {
if (data->bones[ii] == boneData->parent) {
parent = this->bones[ii];
@@ -27,7 +27,7 @@ void Skeleton_init (Skeleton* this, SkeletonData* data) {
for (i = 0; i < this->slotCount; ++i) {
SlotData *slotData = data->slots[i];
- // Find bone for the slotData's boneData.
+ /* Find bone for the slotData's boneData. */
Bone *bone;
for (ii = 0; ii < this->boneCount; ++ii) {
if (data->bones[ii] == slotData->boneData) {
@@ -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)
@@ -125,8 +125,8 @@ int Skeleton_setSkinByName (Skeleton* this, const char* skinName) {
void Skeleton_setSkin (Skeleton* this, Skin* newSkin) {
if (this->skin && newSkin) {
- // Attach each attachment in the new skin if the corresponding attachment in the old skin is currently attached.
- const SkinEntry *entry = this->skin->entryList;
+ /* Attach each attachment in the new skin if the corresponding attachment in the old skin is currently attached. */
+ const SkinEntry *entry = this->skin->entries;
while (entry) {
Slot *slot = this->slots[entry->slotIndex];
if (slot->attachment == entry->attachment) {
diff --git a/spine-c/src/spine/Skeleton.h b/spine-c/src/spine/Skeleton.h
index d817ccd4e..8e81e9416 100644
--- a/spine-c/src/spine/Skeleton.h
+++ b/spine-c/src/spine/Skeleton.h
@@ -24,7 +24,7 @@ struct Skeleton {
Skin* const skin;
float r, g, b, a;
float time;
- int flipX, flipY;
+ int/*bool*/flipX, flipY;
void (*_dispose) (Skeleton* skeleton);
};
@@ -57,11 +57,11 @@ void Skeleton_setSkin (Skeleton* skeleton, Skin* skin);
/** Returns 0 if the slot or attachment could not be found. */
Attachment* Skeleton_getAttachmentForSlotName (const Skeleton* skeleton, const char* slotName, const char* attachmentName);
/** Returns 0 if the slot or attachment could not be found. */
-Attachment* Skeleton_getAttachmentForSlotIndex (const Skeleton* this, int slotIndex, const char* attachmentName);
+Attachment* Skeleton_getAttachmentForSlotIndex (const Skeleton* skeleton, int slotIndex, const char* attachmentName);
/** Returns 0 if the slot or attachment could not be found. */
int Skeleton_setAttachment (Skeleton* skeleton, const char* slotName, const char* attachmentName);
-void Skeleton_update (Skeleton* this, float deltaTime);
+void Skeleton_update (Skeleton* skeleton, float deltaTime);
#ifdef __cplusplus
}
diff --git a/spine-c/src/spine/SkeletonJson.c b/spine-c/src/spine/SkeletonJson.c
index 9f5a5f8a0..77e49b909 100644
--- a/spine-c/src/spine/SkeletonJson.c
+++ b/spine-c/src/spine/SkeletonJson.c
@@ -42,10 +42,10 @@ static float toColor (const char* value, int index) {
}
SkeletonData* SkeletonJson_readSkeletonDataFile (const char* path) {
- char* data = readFile(path);
+ const char* data = readFile(path);
if (!data) return SkeletonJson_setError(0, "Unable to read file: ", path);
SkeletonData* skeletonData = SkeletonJson_readSkeletonData(data);
- free(data);
+ FREE(data)
return skeletonData;
}
diff --git a/spine-c/src/spine/SkeletonJson.h b/spine-c/src/spine/SkeletonJson.h
index b71ac6f5f..477ffd8e7 100644
--- a/spine-c/src/spine/SkeletonJson.h
+++ b/spine-c/src/spine/SkeletonJson.h
@@ -14,7 +14,7 @@ void SkeletonJson_setScale (float scale);
SkeletonData* SkeletonJson_readSkeletonData (const char* json);
SkeletonData* SkeletonJson_readSkeletonDataFile (const char* path);
-// Animation* readAnimation (char* json, const SkeletonData *skeletonData) const;
+/* Animation* readAnimation (char* json, const SkeletonData *skeletonData) const; */
const char* SkeletonJson_getError ();
diff --git a/spine-c/src/spine/Skin.c b/spine-c/src/spine/Skin.c
index 250fbcd4e..f4b84c503 100644
--- a/spine-c/src/spine/Skin.c
+++ b/spine-c/src/spine/Skin.c
@@ -16,7 +16,7 @@ void SkinEntry_dispose (SkinEntry* entry) {
FREE(entry)
}
-//
+/**/
Skin* Skin_create (const char* name) {
Skin* this = calloc(1, sizeof(Skin));
@@ -25,14 +25,14 @@ Skin* Skin_create (const char* name) {
}
void Skin_dispose (Skin* this) {
- SkinEntry_dispose((SkinEntry*)this->entryList);
+ 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* entry = (SkinEntry*)this->entryList;
+ SkinEntry* entry = (SkinEntry*)this->entries;
if (!entry)
entry = newEntry;
else {
@@ -43,7 +43,7 @@ void Skin_addAttachment (Skin* this, int slotIndex, const char* name, Attachment
}
Attachment* Skin_getAttachment (const Skin* this, int slotIndex, const char* name) {
- const SkinEntry* entry = this->entryList;
+ const SkinEntry* entry = this->entries;
while (entry) {
if (entry->slotIndex == slotIndex && strcmp(entry->name, name) == 0) return entry->attachment;
entry = entry->next;
diff --git a/spine-c/src/spine/Skin.h b/spine-c/src/spine/Skin.h
index c1890bdb4..5f192a22c 100644
--- a/spine-c/src/spine/Skin.h
+++ b/spine-c/src/spine/Skin.h
@@ -18,7 +18,7 @@ struct SkinEntry {
typedef struct {
const char* const name;
- const SkinEntry* const entryList;
+ const SkinEntry* const entries;
} Skin;
Skin* Skin_create (const char* name);
diff --git a/spine-c/src/spine/SlotData.h b/spine-c/src/spine/SlotData.h
index 34543efca..d5225bdc0 100644
--- a/spine-c/src/spine/SlotData.h
+++ b/spine-c/src/spine/SlotData.h
@@ -19,7 +19,7 @@ SlotData* SlotData_create (const char* name, BoneData* boneData);
void SlotData_dispose (SlotData* slotData);
/** @param attachmentName May be zero. */
-void SlotData_setAttachmentName (SlotData* this, const char* attachmentName);
+void SlotData_setAttachmentName (SlotData* slotData, const char* attachmentName);
#ifdef __cplusplus
}
diff --git a/spine-c/src/spine/spine.h b/spine-c/src/spine/spine.h
index 08cfa5661..ecd2cb717 100644
--- a/spine-c/src/spine/spine.h
+++ b/spine-c/src/spine/spine.h
@@ -1,6 +1,7 @@
#ifndef SPINE_SPINE_H_
#define SPINE_SPINE_H_
+#include
#include
#include
#include
diff --git a/spine-c/src/spine/util.c b/spine-c/src/spine/util.c
index a58161c4d..5aea5cfc2 100644
--- a/spine-c/src/spine/util.c
+++ b/spine-c/src/spine/util.c
@@ -1,6 +1,7 @@
#include
+#include
-char* readFile (const char* path) {
+const char* readFile (const char* path) {
FILE *file = fopen(path, "rb");
if (!file) return 0;
@@ -8,8 +9,8 @@ char* readFile (const char* path) {
long length = ftell(file);
fseek(file, 0, SEEK_SET);
- char* data = (char*)malloc(sizeof(char) * length + 1);
- fread(data, sizeof(char), length, file);
+ char* data = (char*)malloc(length + 1);
+ fread(data, 1, length, file);
fclose(file);
data[length] = '\0';
diff --git a/spine-c/src/spine/util.h b/spine-c/src/spine/util.h
index 1435d5170..7135a024d 100644
--- a/spine-c/src/spine/util.h
+++ b/spine-c/src/spine/util.h
@@ -1,9 +1,8 @@
#ifndef SPINE_UTIL_H_
#define SPINE_UTIL_H_
-#include
#include
-#include
+#include
/** Used to cast away const on an lvalue. */
#define CAST(TYPE,VALUE) *(TYPE*)&VALUE
@@ -12,6 +11,6 @@
#define FREE(E) free((void*)E);
-char* readFile (const char* path);
+const char* readFile (const char* path);
#endif /* SPINE_UTIL_H_ */