void _spBoundingBoxAttachment_dispose (spAttachment* attachment) {
spBoundingBoxAttachment* self = SUB_CAST(spBoundingBoxAttachment, attachment);
_spAttachment_deinit(attachment);
FREE(self->vertices);
FREE(self);
}
Attachment* Skin_getAttachment (const Skin* self, int slotIndex, const char* name) {
const _Entry* entry = SUB_CAST(_Internal, self) ->entries;
while (entry) {
if (entry->slotIndex == slotIndex && strcmp(entry->name, name) == 0) return entry->attachment;
entry = entry->next;
}
return 0;
}
void spSkeletonBounds_dispose (spSkeletonBounds* self) {
int i;
for (i = 0; i < SUB_CAST(_spSkeletonBounds, self)->capacity; ++i)
if (self->polygons[i]) spPolygon_dispose(self->polygons[i]);
FREE(self->polygons);
FREE(self->boundingBoxes);
FREE(self);
}
void SkeletonBounds_dispose (SkeletonBounds* self) {
int i = 0;
for (; i < SUB_CAST(_Internal, self)->capacity; ++i)
if (self->polygons[i]) BoundingPolygon_dispose(self->polygons[i]);
FREE(self->polygons);
FREE(self->boundingBoxes);
FREE(self);
}
void _spPathAttachment_dispose (spAttachment* attachment) {
spPathAttachment* self = SUB_CAST(spPathAttachment, attachment);
_spVertexAttachment_deinit(SUPER(self));
FREE(self->lengths);
FREE(self);
}
void _Cocos2dxAtlasPage_dispose (AtlasPage* page) {
Cocos2dxAtlasPage* self = SUB_CAST(Cocos2dxAtlasPage, page);
_AtlasPage_deinit(SUPER(self));
CC_SAFE_RELEASE_NULL(self->texture);
CC_SAFE_RELEASE_NULL(self->atlas);
FREE(page);
}
void _Cocos2dxRegionAttachment_draw (Attachment* attachment, Slot* slot) {
Cocos2dxRegionAttachment* self = SUB_CAST(Cocos2dxRegionAttachment, attachment);
Cocos2dxSkeleton* skeleton = SUB_CAST(Cocos2dxSkeleton, slot->skeleton);
GLubyte r = SUPER(skeleton)->r * slot->r * 255;
GLubyte g = SUPER(skeleton)->g * slot->g * 255;
GLubyte b = SUPER(skeleton)->b * slot->b * 255;
GLubyte a = SUPER(skeleton)->a * slot->a * 255;
ccV3F_C4B_T2F_Quad* quad = &self->quad;
quad->bl.colors.r = r;
quad->bl.colors.g = g;
quad->bl.colors.b = b;
quad->bl.colors.a = a;
quad->tl.colors.r = r;
quad->tl.colors.g = g;
quad->tl.colors.b = b;
quad->tl.colors.a = a;
quad->tr.colors.r = r;
quad->tr.colors.g = g;
quad->tr.colors.b = b;
quad->tr.colors.a = a;
quad->br.colors.r = r;
quad->br.colors.g = g;
quad->br.colors.b = b;
quad->br.colors.a = a;
float* offset = SUPER(self)->offset;
quad->bl.vertices.x = offset[0] * slot->bone->m00 + offset[1] * slot->bone->m01 + slot->bone->worldX;
quad->bl.vertices.y = offset[0] * slot->bone->m10 + offset[1] * slot->bone->m11 + slot->bone->worldY;
quad->tl.vertices.x = offset[2] * slot->bone->m00 + offset[3] * slot->bone->m01 + slot->bone->worldX;
quad->tl.vertices.y = offset[2] * slot->bone->m10 + offset[3] * slot->bone->m11 + slot->bone->worldY;
quad->tr.vertices.x = offset[4] * slot->bone->m00 + offset[5] * slot->bone->m01 + slot->bone->worldX;
quad->tr.vertices.y = offset[4] * slot->bone->m10 + offset[5] * slot->bone->m11 + slot->bone->worldY;
quad->br.vertices.x = offset[6] * slot->bone->m00 + offset[7] * slot->bone->m01 + slot->bone->worldX;
quad->br.vertices.y = offset[6] * slot->bone->m10 + offset[7] * slot->bone->m11 + slot->bone->worldY;
// cocos2dx doesn't handle batching for us, so we'll just force a single texture per skeleton.
skeleton->node->atlas = self->atlas;
if (self->atlas->getCapacity() <= skeleton->node->quadCount) {
if (!self->atlas->resizeCapacity(self->atlas->getCapacity() * 2)) return;
}
self->atlas->updateQuad(quad, skeleton->node->quadCount++);
}
void _AnimationState_clearQueue (AnimationState* self) {
_Internal* internal = SUB_CAST(_Internal, self);
_Entry* entry = internal->queue;
while (entry) {
_Entry* nextEntry = entry->next;
FREE(entry);
entry = nextEntry;
}
internal->queue = 0;
}
void _spMeshAttachment_dispose (spAttachment* attachment) {
spMeshAttachment* self = SUB_CAST(spMeshAttachment, attachment);
_spAttachment_deinit(attachment);
FREE(self->path);
FREE(self->vertices);
FREE(self->regionUVs);
FREE(self->uvs);
FREE(self->triangles);
FREE(self->edges);
FREE(self);
}
void spSkin_attachAll (const spSkin* self, spSkeleton* skeleton, const spSkin* oldSkin) {
const _Entry *entry = SUB_CAST(_spSkin, oldSkin)->entries;
while (entry) {
spSlot *slot = skeleton->slots[entry->slotIndex];
if (slot->attachment == entry->attachment) {
spAttachment *attachment = spSkin_getAttachment(self, entry->slotIndex, entry->name);
if (attachment) spSlot_setAttachment(slot, attachment);
}
entry = entry->next;
}
}
void spSkin_dispose (spSkin* self) {
_Entry* entry = SUB_CAST(_spSkin, self)->entries;
while (entry) {
_Entry* nextEntry = entry->next;
_Entry_dispose(entry);
entry = nextEntry;
}
FREE(self->name);
FREE(self);
}
void _spSkinnedMeshAttachment_dispose (spAttachment* attachment) {
spSkinnedMeshAttachment* self = SUB_CAST(spSkinnedMeshAttachment, attachment);
_spAttachment_deinit(attachment);
FREE(self->path);
FREE(self->bones);
FREE(self->weights);
FREE(self->regionUVs);
FREE(self->uvs);
FREE(self->triangles);
FREE(self->edges);
FREE(self);
}
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) {
if (i == attachmentIndex) return entry->name;
i++;
}
entry = entry->next;
}
return 0;
}
void _spMeshAttachment_dispose (spAttachment* attachment) {
spMeshAttachment* self = SUB_CAST(spMeshAttachment, attachment);
FREE(self->path);
FREE(self->uvs);
if (!self->parentMesh) {
_spVertexAttachment_deinit(SUPER(self));
FREE(self->regionUVs);
FREE(self->triangles);
FREE(self->edges);
} else
_spAttachment_deinit(attachment);
FREE(self);
}
ccV3F_C4B_T2F_Quad* RegionAttachment_updateQuad (Attachment* attachment, Slot* slot) {
Cocos2dxRegionAttachment* self = SUB_CAST(Cocos2dxRegionAttachment, attachment);
Cocos2dxSkeleton* skeleton = SUB_CAST(Cocos2dxSkeleton, slot->skeleton);
GLubyte r = SUPER(skeleton)->r * slot->r * 255;
GLubyte g = SUPER(skeleton)->g * slot->g * 255;
GLubyte b = SUPER(skeleton)->b * slot->b * 255;
GLubyte a = SUPER(skeleton)->a * slot->a * 255;
ccV3F_C4B_T2F_Quad* quad = &self->quad;
quad->bl.colors.r = r;
quad->bl.colors.g = g;
quad->bl.colors.b = b;
quad->bl.colors.a = a;
quad->tl.colors.r = r;
quad->tl.colors.g = g;
quad->tl.colors.b = b;
quad->tl.colors.a = a;
quad->tr.colors.r = r;
quad->tr.colors.g = g;
quad->tr.colors.b = b;
quad->tr.colors.a = a;
quad->br.colors.r = r;
quad->br.colors.g = g;
quad->br.colors.b = b;
quad->br.colors.a = a;
float* offset = SUPER(self)->offset;
quad->bl.vertices.x = offset[0] * slot->bone->m00 + offset[1] * slot->bone->m01 + slot->bone->worldX;
quad->bl.vertices.y = offset[0] * slot->bone->m10 + offset[1] * slot->bone->m11 + slot->bone->worldY;
quad->tl.vertices.x = offset[2] * slot->bone->m00 + offset[3] * slot->bone->m01 + slot->bone->worldX;
quad->tl.vertices.y = offset[2] * slot->bone->m10 + offset[3] * slot->bone->m11 + slot->bone->worldY;
quad->tr.vertices.x = offset[4] * slot->bone->m00 + offset[5] * slot->bone->m01 + slot->bone->worldX;
quad->tr.vertices.y = offset[4] * slot->bone->m10 + offset[5] * slot->bone->m11 + slot->bone->worldY;
quad->br.vertices.x = offset[6] * slot->bone->m00 + offset[7] * slot->bone->m01 + slot->bone->worldX;
quad->br.vertices.y = offset[6] * slot->bone->m10 + offset[7] * slot->bone->m11 + slot->bone->worldY;
return quad;
}
void AnimationState_update (AnimationState* self, float delta) {
_Entry* next;
_Internal* internal = SUB_CAST(_Internal, self);
self->time += delta;
internal->previousTime += delta;
internal->mixTime += delta;
if (internal->queue && self->time >= internal->queue->delay) {
_AnimationState_setAnimation(self, internal->queue->animation, internal->queue->loop);
next = internal->queue->next;
FREE(internal->queue);
internal->queue = next;
}
}
Attachment* _AtlasAttachmentLoader_newAttachment (AttachmentLoader* loader, Skin* skin, AttachmentType type, const char* name) {
AtlasAttachmentLoader* self = SUB_CAST(AtlasAttachmentLoader, loader);
switch (type) {
case ATTACHMENT_REGION: {
AtlasRegion* region = Atlas_findRegion(self->atlas, name);
if (!region) {
_AttachmentLoader_setError(loader, "Region not found: ", name);
return 0;
}
return SUPER_CAST(Attachment, RegionAttachment_create(name, region)) ;
}
default:
_AttachmentLoader_setUnknownTypeError(loader, type);
return 0;
}
}
void _AnimationState_setAnimation (AnimationState* self, Animation* newAnimation, int/*bool*/loop) {
_Internal* internal = SUB_CAST(_Internal, self);
internal->previous = 0;
if (newAnimation && self->animation && self->data) {
internal->mixDuration = AnimationStateData_getMix(self->data, self->animation, newAnimation);
if (internal->mixDuration > 0) {
internal->mixTime = 0;
internal->previous = self->animation;
internal->previousTime = self->time;
internal->previousLoop = self->loop;
}
}
CONST_CAST(Animation*, self->animation) = newAnimation;
self->loop = loop;
self->time = 0;
}
void spSkeleton_updateWorldTransform (const spSkeleton* self) {
int i, ii, nn, last;
_spSkeleton* internal = SUB_CAST(_spSkeleton, self);
for (i = 0; i < self->bonesCount; ++i)
self->bones[i]->rotationIK = self->bones[i]->rotation;
i = 0;
last = internal->boneCacheCount - 1;
while (1) {
for (ii = 0, nn = internal->boneCacheCounts[i]; ii < nn; ++ii)
spBone_updateWorldTransform(internal->boneCache[i][ii]);
if (i == last) break;
spIkConstraint_apply(self->ikConstraints[i]);
i++;
}
}
void AnimationState_apply (AnimationState* self, Skeleton* skeleton) {
_Internal* internal;
float alpha;
if (!self->animation) return;
internal = SUB_CAST(_Internal, self);
if (internal->previous) {
Animation_apply(internal->previous, skeleton, internal->previousTime, internal->previousLoop);
alpha = internal->mixTime / internal->mixDuration;
if (alpha >= 1) {
alpha = 1;
internal->previous = 0;
}
Animation_mix(self->animation, skeleton, self->time, self->loop, alpha);
} else
Animation_apply(self->animation, skeleton, self->time, self->loop);
}
void spSkeletonBounds_update (spSkeletonBounds* self, spSkeleton* skeleton, int/*bool*/updateAabb) {
int i;
_spSkeletonBounds* internal = SUB_CAST(_spSkeletonBounds, self);
if (internal->capacity < skeleton->slotsCount) {
spPolygon** newPolygons;
FREE(self->boundingBoxes);
self->boundingBoxes = MALLOC(spBoundingBoxAttachment*, skeleton->slotsCount);
newPolygons = CALLOC(spPolygon*, skeleton->slotsCount);
memcpy(newPolygons, self->polygons, sizeof(spPolygon*) * internal->capacity);
FREE(self->polygons);
self->polygons = newPolygons;
internal->capacity = skeleton->slotsCount;
}
void SkeletonBounds_update (SkeletonBounds* self, Skeleton* skeleton, int/*bool*/updateAabb) {
int i;
_Internal* internal = SUB_CAST(_Internal, self);
if (internal->capacity < skeleton->slotCount) {
BoundingPolygon** newPolygons;
FREE(self->boundingBoxes);
self->boundingBoxes = MALLOC(BoundingBoxAttachment*, skeleton->slotCount);
newPolygons = CALLOC(BoundingPolygon*, skeleton->slotCount);
memcpy(newPolygons, self->polygons, internal->capacity);
FREE(self->polygons);
self->polygons = newPolygons;
internal->capacity = skeleton->slotCount;
}
void spSkeleton_updateWorldTransform (const spSkeleton* self) {
int i;
_spSkeleton* internal = SUB_CAST(_spSkeleton, self);
for (i = 0; i < internal->updateCacheCount; ++i) {
_spUpdate* update = internal->updateCache + i;
switch (update->type) {
case SP_UPDATE_BONE:
spBone_updateWorldTransform((spBone*)update->object);
break;
case SP_UPDATE_IK_CONSTRAINT:
spIkConstraint_apply((spIkConstraint*)update->object);
break;
case SP_UPDATE_TRANSFORM_CONSTRAINT:
spTransformConstraint_apply((spTransformConstraint*)update->object);
break;
}
}
}
void spSkeleton_updateCache (const spSkeleton* self) {
int i, ii;
_spUpdate* update;
_spSkeleton* internal = SUB_CAST(_spSkeleton, self);
int capacity = self->bonesCount + self->transformConstraintsCount + self->ikConstraintsCount;
FREE(internal->updateCache);
internal->updateCache = MALLOC(_spUpdate, capacity);
internal->updateCacheCount = 0;
for (i = 0; i < self->bonesCount; ++i) {
spBone* bone = self->bones[i];
update = internal->updateCache + internal->updateCacheCount++;
update->type = SP_UPDATE_BONE;
update->object = bone;
for (ii = 0; ii < self->ikConstraintsCount; ++ii) {
spIkConstraint* ikConstraint = self->ikConstraints[ii];
if (bone == ikConstraint->bones[ikConstraint->bonesCount - 1]) {
update = internal->updateCache + internal->updateCacheCount++;
update->type = SP_UPDATE_IK_CONSTRAINT;
update->object = ikConstraint;
break;
}
}
}
for (i = 0; i < self->transformConstraintsCount; ++i) {
spTransformConstraint* transformConstraint = self->transformConstraints[i];
for (ii = internal->updateCacheCount - 1; ii >= 0; --ii) {
if (internal->updateCache[ii].object == transformConstraint->bone) {
int insertIndex = ii + 1;
update = internal->updateCache + insertIndex;
memmove(update + 1, update, (internal->updateCacheCount - insertIndex) * sizeof(_spUpdate));
update->type = SP_UPDATE_TRANSFORM_CONSTRAINT;
update->object = transformConstraint;
internal->updateCacheCount++;
break;
}
}
}
}
RegionAttachment* RegionAttachment_create (const char* name, AtlasRegion* region) {
Cocos2dxRegionAttachment* self = NEW(Cocos2dxRegionAttachment);
_RegionAttachment_init(SUPER(self), name);
VTABLE(Attachment, self) ->dispose = _Cocos2dxRegionAttachment_dispose;
VTABLE(Attachment, self) ->draw = _Cocos2dxRegionAttachment_draw;
Cocos2dxAtlasPage* page = SUB_CAST(Cocos2dxAtlasPage, region->page);
self->atlas = page->atlas;
const CCSize& size = page->texture->getContentSizeInPixels();
float u = region->x / size.width;
float u2 = (region->x + region->width) / size.width;
float v = region->y / size.height;
float v2 = (region->y + region->height) / size.height;
ccV3F_C4B_T2F_Quad* quad = &self->quad;
if (region->rotate) {
quad->tl.texCoords.u = u;
quad->tl.texCoords.v = v2;
quad->tr.texCoords.u = u;
quad->tr.texCoords.v = v;
quad->br.texCoords.u = u2;
quad->br.texCoords.v = v;
quad->bl.texCoords.u = u2;
quad->bl.texCoords.v = v2;
} else {
quad->bl.texCoords.u = u;
quad->bl.texCoords.v = v2;
quad->tl.texCoords.u = u;
quad->tl.texCoords.v = v;
quad->tr.texCoords.u = u2;
quad->tr.texCoords.v = v;
quad->br.texCoords.u = u2;
quad->br.texCoords.v = v2;
}
quad->bl.vertices.z = 0;
quad->tl.vertices.z = 0;
quad->tr.vertices.z = 0;
quad->br.vertices.z = 0;
return SUPER(self);
}
void spSkeleton_dispose (spSkeleton* self) {
int i;
_spSkeleton* internal = SUB_CAST(_spSkeleton, self);
for (i = 0; i < internal->boneCacheCount; ++i)
FREE(internal->boneCache[i]);
FREE(internal->boneCache);
FREE(internal->boneCacheCounts);
for (i = 0; i < self->bonesCount; ++i)
spBone_dispose(self->bones[i]);
FREE(self->bones);
for (i = 0; i < self->slotsCount; ++i)
spSlot_dispose(self->slots[i]);
FREE(self->slots);
for (i = 0; i < self->ikConstraintsCount; ++i)
spIkConstraint_dispose(self->ikConstraints[i]);
FREE(self->ikConstraints);
FREE(self->drawOrder);
FREE(self);
}
void spSkin_addAttachment (spSkin* self, int slotIndex, const char* name, spAttachment* attachment) {
_Entry* newEntry = _Entry_create(slotIndex, name, attachment);
newEntry->next = SUB_CAST(_spSkin, self)->entries;
SUB_CAST(_spSkin, self)->entries = newEntry;
}
float Slot_getAttachmentTime (const Slot* self) {
return self->skeleton->time - SUB_CAST(_Internal, self) ->attachmentTime;
}
void Slot_setAttachmentTime (Slot* self, float time) {
SUB_CAST(_Internal, self) ->attachmentTime = self->skeleton->time - time;
}
void Slot_setAttachment (Slot* self, Attachment* attachment) {
CONST_CAST(Attachment*, self->attachment) = attachment;
SUB_CAST(_Internal, self) ->attachmentTime = self->skeleton->time;
}
