UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2025-12-21 09:46:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Done.

Browse Source
This commit is contained in:
Stephen Gowen 2017-12-06 19:00:42 -05:00
parent e20382a304
commit 7b32f02e2c
1 changed files with 210 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

423
spine-cpp/spine-cpp/src/spine/SkeletonJson.cpp
View File

@ -543,237 +543,232 @@ namespace Spine
return NULL; return NULL;
} }
// switch (type) switch (type)
// { {
// case AttachmentType_Region: case AttachmentType_Region:
// { {
// attachment = _attachmentLoader->newRegionAttachment(*skin, attachmentName, attachmentPath); attachment = _attachmentLoader->newRegionAttachment(*skin, attachmentName, attachmentPath);
// if (!attachment) if (!attachment)
// { {
// DESTROY(SkeletonData, skeletonData); DESTROY(SkeletonData, skeletonData);
// setError(root, "Error reading attachment: ", skinAttachmentName); setError(root, "Error reading attachment: ", skinAttachmentName);
// return NULL; return NULL;
// } }
//
// RegionAttachment* region = static_cast<RegionAttachment*>(attachment); RegionAttachment* region = static_cast<RegionAttachment*>(attachment);
// region->_path = attachmentPath; region->_path = attachmentPath;
//
// region->_x = Json::getFloat(attachmentMap, "x", 0) * _scale; region->_x = Json::getFloat(attachmentMap, "x", 0) * _scale;
// region->_y = Json::getFloat(attachmentMap, "y", 0) * _scale; region->_y = Json::getFloat(attachmentMap, "y", 0) * _scale;
// region->_scaleX = Json::getFloat(attachmentMap, "scaleX", 1); region->_scaleX = Json::getFloat(attachmentMap, "scaleX", 1);
// region->_scaleY = Json::getFloat(attachmentMap, "scaleY", 1); region->_scaleY = Json::getFloat(attachmentMap, "scaleY", 1);
// region->_rotation = Json::getFloat(attachmentMap, "rotation", 0); region->_rotation = Json::getFloat(attachmentMap, "rotation", 0);
// region->_width = Json::getFloat(attachmentMap, "width", 32) * _scale; region->_width = Json::getFloat(attachmentMap, "width", 32) * _scale;
// region->_height = Json::getFloat(attachmentMap, "height", 32) * _scale; region->_height = Json::getFloat(attachmentMap, "height", 32) * _scale;
//
// color = Json::getString(attachmentMap, "color", 0); color = Json::getString(attachmentMap, "color", 0);
// if (color) if (color)
// { {
// spColor_setFromFloats(&region->color, region->_r = toColor(color, 0);
// toColor(color, 0), region->_g = toColor(color, 1);
// toColor(color, 1), region->_b = toColor(color, 2);
// toColor(color, 2), region->_a = toColor(color, 3);
// toColor(color, 3)); }
// }
// region->updateOffset();
// region->updateOffset();
// break;
// break; }
// } case AttachmentType_Mesh:
// case AttachmentType_Mesh: case AttachmentType_Linkedmesh:
// case AttachmentType_Linkedmesh: {
// { attachment = _attachmentLoader->newMeshAttachment(*skin, attachmentName, attachmentPath);
// MeshAttachment* mesh = SUB_CAST(MeshAttachment, attachment);
// MeshAttachment* mesh = static_cast<MeshAttachment*>(attachment);
// MALLOC_STR(mesh->path, attachmentPath); mesh->_path = attachmentPath;
//
// color = Json::getString(attachmentMap, "color", 0); color = Json::getString(attachmentMap, "color", 0);
// if (color) if (color)
// { {
// spColor_setFromFloats(&mesh->color, mesh->_r = toColor(color, 0);
// toColor(color, 0), mesh->_g = toColor(color, 1);
// toColor(color, 1), mesh->_b = toColor(color, 2);
// toColor(color, 2), mesh->_a = toColor(color, 3);
// toColor(color, 3)); }
// }
// mesh->_width = Json::getFloat(attachmentMap, "width", 32) * _scale;
// mesh->width = Json::getFloat(attachmentMap, "width", 32) * _scale; mesh->_height = Json::getFloat(attachmentMap, "height", 32) * _scale;
// mesh->height = Json::getFloat(attachmentMap, "height", 32) * _scale;
// entry = Json::getItem(attachmentMap, "parent");
// entry = Json::getItem(attachmentMap, "parent"); if (!entry)
// if (!entry) {
// { int verticesLength;
// int verticesLength; entry = Json::getItem(attachmentMap, "triangles");
// entry = Json::getItem(attachmentMap, "triangles"); mesh->_triangles.reserve(entry->_size);
// mesh->_triangles.reserve(entry->_size); for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii)
// for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii) {
// { mesh->_triangles[ii] = (unsigned short)entry->_valueInt;
// mesh->triangles[ii] = (unsigned short)entry->_valueInt; }
// }
// entry = Json::getItem(attachmentMap, "uvs");
// entry = Json::getItem(attachmentMap, "uvs"); verticesLength = entry->_size;
// verticesLength = entry->_size; mesh->_regionUVs.reserve(verticesLength);
// mesh->_regionUVs.reserve(verticesLength); for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii)
// for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii) {
// { mesh->_regionUVs[ii] = entry->_valueFloat;
// mesh->regionUVs[ii] = entry->_valueFloat; }
// }
// readVertices(attachmentMap, mesh, verticesLength);
// _readVertices(self, attachmentMap, SUPER(mesh), verticesLength);
// mesh->updateUVs();
// MeshAttachment_updateUVs(mesh);
// mesh->_hullLength = Json::getInt(attachmentMap, "hull", 0);
// mesh->hullLength = Json::getInt(attachmentMap, "hull", 0);
// entry = Json::getItem(attachmentMap, "edges");
// entry = Json::getItem(attachmentMap, "edges"); if (entry)
// if (entry) {
// { mesh->_edges.reserve(entry->_size);
// mesh->edgesCount = entry->_size; for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii)
// mesh->_edges.reserve(entry->_size); {
// for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii) mesh->_edges[ii] = entry->_valueInt;
// { }
// mesh->edges[ii] = entry->_valueInt; }
// } }
// } else
// } {
// else mesh->_inheritDeform = Json::getInt(attachmentMap, "deform", 1);
// { LinkedMesh* linkedMesh = NEW(LinkedMesh);
// mesh->inheritDeform = Json::getInt(attachmentMap, "deform", 1); new (linkedMesh) LinkedMesh(mesh, std::string(Json::getString(attachmentMap, "skin", 0)), slotIndex, std::string(entry->_valueString));
// _spSkeletonJson_addLinkedMesh(self, SUB_CAST(MeshAttachment, attachment), Json::getString(attachmentMap, "skin", 0), slotIndex, _linkedMeshes.push_back(linkedMesh);
// entry->_valueString); }
// } break;
// break; }
// } case AttachmentType_Boundingbox:
// case AttachmentType_Boundingbox: {
// { attachment = _attachmentLoader->newBoundingBoxAttachment(*skin, attachmentName);
// BoundingBoxAttachment* box = SUB_CAST(BoundingBoxAttachment, attachment);
// int vertexCount = Json::getInt(attachmentMap, "vertexCount", 0) << 1; BoundingBoxAttachment* box = static_cast<BoundingBoxAttachment*>(attachment);
// _readVertices(self, attachmentMap, SUPER(box), vertexCount);
// box->super.verticesCount = vertexCount; int vertexCount = Json::getInt(attachmentMap, "vertexCount", 0) << 1;
// break; readVertices(attachmentMap, box, vertexCount);
// } break;
// case AttachmentType_Path: }
// { case AttachmentType_Path:
// PathAttachment* pathAttatchment = SUB_CAST(PathAttachment, attachment); {
// int vertexCount = 0; attachment = _attachmentLoader->newPathAttachment(*skin, attachmentName);
// pathAttatchment->closed = Json::getInt(attachmentMap, "closed", 0);
// pathAttatchment->constantSpeed = Json::getInt(attachmentMap, "constantSpeed", 1); PathAttachment* pathAttatchment = static_cast<PathAttachment*>(attachment);
// vertexCount = Json::getInt(attachmentMap, "vertexCount", 0);
// _readVertices(self, attachmentMap, SUPER(pathAttatchment), vertexCount << 1); int vertexCount = 0;
// pathAttatchment->_closed = Json::getInt(attachmentMap, "closed", 0);
// pathAttatchment->lengthsLength = vertexCount / 3; pathAttatchment->_constantSpeed = Json::getInt(attachmentMap, "constantSpeed", 1);
// pathAttatchment->_lengths.reserve(vertexCount / 3); vertexCount = Json::getInt(attachmentMap, "vertexCount", 0);
// readVertices(attachmentMap, pathAttatchment, vertexCount << 1);
// curves = Json::getItem(attachmentMap, "lengths");
// for (curves = curves->_child, ii = 0; curves; curves = curves->_next, ++ii) pathAttatchment->_lengths.reserve(vertexCount / 3);
// {
// pathAttatchment->lengths[ii] = curves->_valueFloat * _scale; curves = Json::getItem(attachmentMap, "lengths");
// } for (curves = curves->_child, ii = 0; curves; curves = curves->_next, ++ii)
// break; {
// } pathAttatchment->_lengths[ii] = curves->_valueFloat * _scale;
// case AttachmentType_Point: }
// { break;
// PointAttachment* point = SUB_CAST(PointAttachment, attachment); }
// point->x = Json::getFloat(attachmentMap, "x", 0) * _scale; case AttachmentType_Point:
// point->y = Json::getFloat(attachmentMap, "y", 0) * _scale; {
// point->rotation = Json::getFloat(attachmentMap, "rotation", 0); attachment = _attachmentLoader->newPointAttachment(*skin, attachmentName);
//
// color = Json::getString(attachmentMap, "color", 0); PointAttachment* point = static_cast<PointAttachment*>(attachment);
// if (color)
// { point->_x = Json::getFloat(attachmentMap, "x", 0) * _scale;
// spColor_setFromFloats(&point->color, point->_y = Json::getFloat(attachmentMap, "y", 0) * _scale;
// toColor(color, 0), point->_rotation = Json::getFloat(attachmentMap, "rotation", 0);
// toColor(color, 1), break;
// toColor(color, 2), }
// toColor(color, 3)); case AttachmentType_Clipping:
// } {
// break; attachment = _attachmentLoader->newClippingAttachment(*skin, attachmentName);
// }
// case AttachmentType_Clipping: ClippingAttachment* clip = static_cast<ClippingAttachment*>(attachment);
// {
// ClippingAttachment* clip = SUB_CAST(ClippingAttachment, attachment); int vertexCount = 0;
// int vertexCount = 0; const char* end = Json::getString(attachmentMap, "end", 0);
// const char* end = Json::getString(attachmentMap, "end", 0); if (end)
// if (end) {
// { SlotData* slot = skeletonData->findSlot(end);
// spSlotData* slot = skeletonData->findSlot(end); clip->_endSlot = slot;
// clip->endSlot = slot; }
// } vertexCount = Json::getInt(attachmentMap, "vertexCount", 0) << 1;
// vertexCount = Json::getInt(attachmentMap, "vertexCount", 0) << 1; readVertices(attachmentMap, clip, vertexCount);
// _readVertices(self, attachmentMap, SUPER(clip), vertexCount); break;
// break; }
// } }
// }
// skin->addAttachment(slotIndex, skinAttachmentName, attachment);
// Skin_addAttachment(skin, slotIndex, skinAttachmentName, attachment);
} }
} }
} }
} }
/* Linked meshes. */ /* Linked meshes. */
// for (i = 0; i < internal->linkedMeshCount; i++) for (int i = 0, n = static_cast<int>(_linkedMeshes.size()); i < n; ++i)
// { {
// Attachment* parent; LinkedMesh* linkedMesh = _linkedMeshes[i];
// _spLinkedMesh* linkedMesh = internal->linkedMeshes + i; Skin* skin = linkedMesh->_skin.length() == 0 ? skeletonData->getDefaultSkin() : skeletonData->findSkin(linkedMesh->_skin);
// Skin* skin = !linkedMesh->skin ? skeletonData->_defaultSkin : SkeletonData_findSkin(skeletonData, linkedMesh->skin); if (skin == NULL)
// if (!skin) {
// { DESTROY(SkeletonData, skeletonData);
// DESTROY(SkeletonData, skeletonData); setError(root, "Skin not found: ", linkedMesh->_skin.c_str());
// setError(root, "Skin not found: ", linkedMesh->skin); return NULL;
// return NULL; }
// } Attachment* parent = skin->getAttachment(linkedMesh->_slotIndex, linkedMesh->_parent);
// parent = Skin_getAttachment(skin, linkedMesh->slotIndex, linkedMesh->parent); if (parent == NULL)
// if (!parent) {
// { DESTROY(SkeletonData, skeletonData);
// DESTROY(SkeletonData, skeletonData); setError(root, "Parent mesh not found: ", linkedMesh->_parent.c_str());
// setError(root, "Parent mesh not found: ", linkedMesh->parent); return NULL;
// return NULL; }
// } linkedMesh->_mesh->_parentMesh = static_cast<MeshAttachment*>(parent);
// MeshAttachment_setParentMesh(linkedMesh->mesh, SUB_CAST(MeshAttachment, parent)); linkedMesh->_mesh->updateUVs();
// MeshAttachment_updateUVs(linkedMesh->mesh); }
// AttachmentLoader_configureAttachment(_attachmentLoader, SUPER(SUPER(linkedMesh->mesh))); _linkedMeshes.clear();
// }
/* Events. */ /* Events. */
events = Json::getItem(root, "events"); events = Json::getItem(root, "events");
if (events) if (events)
{ {
// Json *eventMap; Json *eventMap;
// const char* stringValue; skeletonData->_events.reserve(events->_size);
// skeletonData->_events.reserve(events->_size); for (eventMap = events->_child, i = 0; eventMap; eventMap = eventMap->_next, ++i)
// for (eventMap = events->_child, i = 0; eventMap; eventMap = eventMap->_next, ++i) {
// { EventData* eventData = NEW(EventData);
// EventData* eventData = EventData_create(eventMap->_name); new (eventData) EventData(std::string(eventMap->_name));
// eventData->intValue = Json::getInt(eventMap, "int", 0);
// eventData->floatValue = Json::getFloat(eventMap, "float", 0); eventData->_intValue = Json::getInt(eventMap, "int", 0);
// stringValue = Json::getString(eventMap, "string", 0); eventData->_floatValue = Json::getFloat(eventMap, "float", 0);
// if (stringValue) eventData->_stringValue = Json::getString(eventMap, "string", 0);
// { skeletonData->_events[i] = eventData;
// MALLOC_STR(eventData->stringValue, stringValue); }
// }
// skeletonData->_events[i] = eventData;
// }
} }
/* Animations. */ /* Animations. */
animations = Json::getItem(root, "animations"); animations = Json::getItem(root, "animations");
if (animations) if (animations)
{ {
// Json *animationMap; Json *animationMap;
// skeletonData->_animations.reserve(animations->_size); skeletonData->_animations.reserve(animations->_size);
// int animationsIndex = 0; int animationsIndex = 0;
// for (animationMap = animations->_child; animationMap; animationMap = animationMap->_next) for (animationMap = animations->_child; animationMap; animationMap = animationMap->_next)
// { {
// Animation* animation = readAnimation(animationMap, skeletonData); Animation* animation = readAnimation(animationMap, skeletonData);
// if (!animation) if (!animation)
// { {
// DESTROY(SkeletonData, SkeletonData); DESTROY(SkeletonData, skeletonData);
// DESTROY(Json, root); DESTROY(Json, root);
// return NULL; return NULL;
// } }
// skeletonData->_animations[animationsIndex++] = animation; skeletonData->_animations[animationsIndex++] = animation;
// } }
} }
DESTROY(Json, root); DESTROY(Json, root);