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

[c][cpp] Fix DataInput.read() to return unsigned int, fixes SkeletonBinary parsing. Remove findXXXConstraint methods from SkeletonData.

Browse Source
This commit is contained in:
Mario Zechner 2025-07-11 02:48:54 +02:00
parent ab9f6f6099
commit f9fad00936
9 changed files with 9 additions and 576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
spine-c/codegen/spine-cpp-types.json
View File

@ -28505,66 +28505,6 @@
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "findIkConstraint",
"returnType": "IkConstraintData *",
"parameters": [
{
"name": "constraintName",
"type": "const String &"
}
],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "findTransformConstraint",
"returnType": "TransformConstraintData *",
"parameters": [
{
"name": "constraintName",
"type": "const String &"
}
],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "findPathConstraint",
"returnType": "PathConstraintData *",
"parameters": [
{
"name": "constraintName",
"type": "const String &"
}
],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "findPhysicsConstraint",
"returnType": "PhysicsConstraintData *",
"parameters": [
{
"name": "constraintName",
"type": "const String &"
}
],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "getName",
@ -28665,46 +28605,6 @@
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "getIkConstraints",
"returnType": "Array<IkConstraintData *> &",
"parameters": [],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "getTransformConstraints",
"returnType": "Array<TransformConstraintData *> &",
"parameters": [],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "getPathConstraints",
"returnType": "Array<PathConstraintData *> &",
"parameters": [],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "getPhysicsConstraints",
"returnType": "Array<PhysicsConstraintData *> &",
"parameters": [],
"isStatic": false,
"isVirtual": false,
"isPure": false,
"isConst": false
},
{
"kind": "method",
"name": "getConstraints",

232
spine-c/src/generated/arrays.cpp
View File

@ -1018,122 +1018,6 @@ spine_from_property * spine_array_from_property_buffer(spine_array_from_property
return (spine_from_property *)((Array<FromProperty *>*)array)->buffer();
}
spine_array_ik_constraint_data spine_array_ik_constraint_data_create(void) {
return (spine_array_ik_constraint_data) new (__FILE__, __LINE__) Array<IkConstraintData *>();
}
spine_array_ik_constraint_data spine_array_ik_constraint_data_create_with_capacity(size_t initialCapacity) {
return (spine_array_ik_constraint_data) new (__FILE__, __LINE__) Array<IkConstraintData *>(initialCapacity);
}
void spine_array_ik_constraint_data_dispose(spine_array_ik_constraint_data array) {
delete (Array<IkConstraintData *>*)array;
}
void spine_array_ik_constraint_data_clear(spine_array_ik_constraint_data array) {
((Array<IkConstraintData *>*)array)->clear();
}
size_t spine_array_ik_constraint_data_get_capacity(spine_array_ik_constraint_data array) {
return ((Array<IkConstraintData *>*)array)->getCapacity();
}
size_t spine_array_ik_constraint_data_size(spine_array_ik_constraint_data array) {
return ((Array<IkConstraintData *>*)array)->size();
}
spine_array_ik_constraint_data spine_array_ik_constraint_data_set_size(spine_array_ik_constraint_data array, size_t newSize, spine_ik_constraint_data defaultValue) {
return (spine_array_ik_constraint_data)&((Array<IkConstraintData *>*)array)->setSize(newSize, (IkConstraintData *)defaultValue);
}
void spine_array_ik_constraint_data_ensure_capacity(spine_array_ik_constraint_data array, size_t newCapacity) {
((Array<IkConstraintData *>*)array)->ensureCapacity(newCapacity);
}
void spine_array_ik_constraint_data_add(spine_array_ik_constraint_data array, spine_ik_constraint_data inValue) {
((Array<IkConstraintData *>*)array)->add((IkConstraintData *)inValue);
}
void spine_array_ik_constraint_data_add_all(spine_array_ik_constraint_data array, spine_array_ik_constraint_data inValue) {
((Array<IkConstraintData *>*)array)->addAll(*((const Array<IkConstraintData *>*)inValue));
}
void spine_array_ik_constraint_data_clear_and_add_all(spine_array_ik_constraint_data array, spine_array_ik_constraint_data inValue) {
((Array<IkConstraintData *>*)array)->clearAndAddAll(*((const Array<IkConstraintData *>*)inValue));
}
void spine_array_ik_constraint_data_remove_at(spine_array_ik_constraint_data array, size_t inIndex) {
((Array<IkConstraintData *>*)array)->removeAt(inIndex);
}
bool spine_array_ik_constraint_data_contains(spine_array_ik_constraint_data array, spine_ik_constraint_data inValue) {
return ((Array<IkConstraintData *>*)array)->contains((IkConstraintData *)inValue);
}
int spine_array_ik_constraint_data_index_of(spine_array_ik_constraint_data array, spine_ik_constraint_data inValue) {
return ((Array<IkConstraintData *>*)array)->indexOf((IkConstraintData *)inValue);
}
spine_ik_constraint_data * spine_array_ik_constraint_data_buffer(spine_array_ik_constraint_data array) {
return (spine_ik_constraint_data *)((Array<IkConstraintData *>*)array)->buffer();
}
spine_array_path_constraint_data spine_array_path_constraint_data_create(void) {
return (spine_array_path_constraint_data) new (__FILE__, __LINE__) Array<PathConstraintData *>();
}
spine_array_path_constraint_data spine_array_path_constraint_data_create_with_capacity(size_t initialCapacity) {
return (spine_array_path_constraint_data) new (__FILE__, __LINE__) Array<PathConstraintData *>(initialCapacity);
}
void spine_array_path_constraint_data_dispose(spine_array_path_constraint_data array) {
delete (Array<PathConstraintData *>*)array;
}
void spine_array_path_constraint_data_clear(spine_array_path_constraint_data array) {
((Array<PathConstraintData *>*)array)->clear();
}
size_t spine_array_path_constraint_data_get_capacity(spine_array_path_constraint_data array) {
return ((Array<PathConstraintData *>*)array)->getCapacity();
}
size_t spine_array_path_constraint_data_size(spine_array_path_constraint_data array) {
return ((Array<PathConstraintData *>*)array)->size();
}
spine_array_path_constraint_data spine_array_path_constraint_data_set_size(spine_array_path_constraint_data array, size_t newSize, spine_path_constraint_data defaultValue) {
return (spine_array_path_constraint_data)&((Array<PathConstraintData *>*)array)->setSize(newSize, (PathConstraintData *)defaultValue);
}
void spine_array_path_constraint_data_ensure_capacity(spine_array_path_constraint_data array, size_t newCapacity) {
((Array<PathConstraintData *>*)array)->ensureCapacity(newCapacity);
}
void spine_array_path_constraint_data_add(spine_array_path_constraint_data array, spine_path_constraint_data inValue) {
((Array<PathConstraintData *>*)array)->add((PathConstraintData *)inValue);
}
void spine_array_path_constraint_data_add_all(spine_array_path_constraint_data array, spine_array_path_constraint_data inValue) {
((Array<PathConstraintData *>*)array)->addAll(*((const Array<PathConstraintData *>*)inValue));
}
void spine_array_path_constraint_data_clear_and_add_all(spine_array_path_constraint_data array, spine_array_path_constraint_data inValue) {
((Array<PathConstraintData *>*)array)->clearAndAddAll(*((const Array<PathConstraintData *>*)inValue));
}
void spine_array_path_constraint_data_remove_at(spine_array_path_constraint_data array, size_t inIndex) {
((Array<PathConstraintData *>*)array)->removeAt(inIndex);
}
bool spine_array_path_constraint_data_contains(spine_array_path_constraint_data array, spine_path_constraint_data inValue) {
return ((Array<PathConstraintData *>*)array)->contains((PathConstraintData *)inValue);
}
int spine_array_path_constraint_data_index_of(spine_array_path_constraint_data array, spine_path_constraint_data inValue) {
return ((Array<PathConstraintData *>*)array)->indexOf((PathConstraintData *)inValue);
}
spine_path_constraint_data * spine_array_path_constraint_data_buffer(spine_array_path_constraint_data array) {
return (spine_path_constraint_data *)((Array<PathConstraintData *>*)array)->buffer();
}
spine_array_physics_constraint spine_array_physics_constraint_create(void) {
return (spine_array_physics_constraint) new (__FILE__, __LINE__) Array<PhysicsConstraint *>();
}
@ -1192,64 +1076,6 @@ spine_physics_constraint * spine_array_physics_constraint_buffer(spine_array_phy
return (spine_physics_constraint *)((Array<PhysicsConstraint *>*)array)->buffer();
}
spine_array_physics_constraint_data spine_array_physics_constraint_data_create(void) {
return (spine_array_physics_constraint_data) new (__FILE__, __LINE__) Array<PhysicsConstraintData *>();
}
spine_array_physics_constraint_data spine_array_physics_constraint_data_create_with_capacity(size_t initialCapacity) {
return (spine_array_physics_constraint_data) new (__FILE__, __LINE__) Array<PhysicsConstraintData *>(initialCapacity);
}
void spine_array_physics_constraint_data_dispose(spine_array_physics_constraint_data array) {
delete (Array<PhysicsConstraintData *>*)array;
}
void spine_array_physics_constraint_data_clear(spine_array_physics_constraint_data array) {
((Array<PhysicsConstraintData *>*)array)->clear();
}
size_t spine_array_physics_constraint_data_get_capacity(spine_array_physics_constraint_data array) {
return ((Array<PhysicsConstraintData *>*)array)->getCapacity();
}
size_t spine_array_physics_constraint_data_size(spine_array_physics_constraint_data array) {
return ((Array<PhysicsConstraintData *>*)array)->size();
}
spine_array_physics_constraint_data spine_array_physics_constraint_data_set_size(spine_array_physics_constraint_data array, size_t newSize, spine_physics_constraint_data defaultValue) {
return (spine_array_physics_constraint_data)&((Array<PhysicsConstraintData *>*)array)->setSize(newSize, (PhysicsConstraintData *)defaultValue);
}
void spine_array_physics_constraint_data_ensure_capacity(spine_array_physics_constraint_data array, size_t newCapacity) {
((Array<PhysicsConstraintData *>*)array)->ensureCapacity(newCapacity);
}
void spine_array_physics_constraint_data_add(spine_array_physics_constraint_data array, spine_physics_constraint_data inValue) {
((Array<PhysicsConstraintData *>*)array)->add((PhysicsConstraintData *)inValue);
}
void spine_array_physics_constraint_data_add_all(spine_array_physics_constraint_data array, spine_array_physics_constraint_data inValue) {
((Array<PhysicsConstraintData *>*)array)->addAll(*((const Array<PhysicsConstraintData *>*)inValue));
}
void spine_array_physics_constraint_data_clear_and_add_all(spine_array_physics_constraint_data array, spine_array_physics_constraint_data inValue) {
((Array<PhysicsConstraintData *>*)array)->clearAndAddAll(*((const Array<PhysicsConstraintData *>*)inValue));
}
void spine_array_physics_constraint_data_remove_at(spine_array_physics_constraint_data array, size_t inIndex) {
((Array<PhysicsConstraintData *>*)array)->removeAt(inIndex);
}
bool spine_array_physics_constraint_data_contains(spine_array_physics_constraint_data array, spine_physics_constraint_data inValue) {
return ((Array<PhysicsConstraintData *>*)array)->contains((PhysicsConstraintData *)inValue);
}
int spine_array_physics_constraint_data_index_of(spine_array_physics_constraint_data array, spine_physics_constraint_data inValue) {
return ((Array<PhysicsConstraintData *>*)array)->indexOf((PhysicsConstraintData *)inValue);
}
spine_physics_constraint_data * spine_array_physics_constraint_data_buffer(spine_array_physics_constraint_data array) {
return (spine_physics_constraint_data *)((Array<PhysicsConstraintData *>*)array)->buffer();
}
spine_array_polygon spine_array_polygon_create(void) {
return (spine_array_polygon) new (__FILE__, __LINE__) Array<Polygon *>();
}
@ -1714,64 +1540,6 @@ spine_track_entry * spine_array_track_entry_buffer(spine_array_track_entry array
return (spine_track_entry *)((Array<TrackEntry *>*)array)->buffer();
}
spine_array_transform_constraint_data spine_array_transform_constraint_data_create(void) {
return (spine_array_transform_constraint_data) new (__FILE__, __LINE__) Array<TransformConstraintData *>();
}
spine_array_transform_constraint_data spine_array_transform_constraint_data_create_with_capacity(size_t initialCapacity) {
return (spine_array_transform_constraint_data) new (__FILE__, __LINE__) Array<TransformConstraintData *>(initialCapacity);
}
void spine_array_transform_constraint_data_dispose(spine_array_transform_constraint_data array) {
delete (Array<TransformConstraintData *>*)array;
}
void spine_array_transform_constraint_data_clear(spine_array_transform_constraint_data array) {
((Array<TransformConstraintData *>*)array)->clear();
}
size_t spine_array_transform_constraint_data_get_capacity(spine_array_transform_constraint_data array) {
return ((Array<TransformConstraintData *>*)array)->getCapacity();
}
size_t spine_array_transform_constraint_data_size(spine_array_transform_constraint_data array) {
return ((Array<TransformConstraintData *>*)array)->size();
}
spine_array_transform_constraint_data spine_array_transform_constraint_data_set_size(spine_array_transform_constraint_data array, size_t newSize, spine_transform_constraint_data defaultValue) {
return (spine_array_transform_constraint_data)&((Array<TransformConstraintData *>*)array)->setSize(newSize, (TransformConstraintData *)defaultValue);
}
void spine_array_transform_constraint_data_ensure_capacity(spine_array_transform_constraint_data array, size_t newCapacity) {
((Array<TransformConstraintData *>*)array)->ensureCapacity(newCapacity);
}
void spine_array_transform_constraint_data_add(spine_array_transform_constraint_data array, spine_transform_constraint_data inValue) {
((Array<TransformConstraintData *>*)array)->add((TransformConstraintData *)inValue);
}
void spine_array_transform_constraint_data_add_all(spine_array_transform_constraint_data array, spine_array_transform_constraint_data inValue) {
((Array<TransformConstraintData *>*)array)->addAll(*((const Array<TransformConstraintData *>*)inValue));
}
void spine_array_transform_constraint_data_clear_and_add_all(spine_array_transform_constraint_data array, spine_array_transform_constraint_data inValue) {
((Array<TransformConstraintData *>*)array)->clearAndAddAll(*((const Array<TransformConstraintData *>*)inValue));
}
void spine_array_transform_constraint_data_remove_at(spine_array_transform_constraint_data array, size_t inIndex) {
((Array<TransformConstraintData *>*)array)->removeAt(inIndex);
}
bool spine_array_transform_constraint_data_contains(spine_array_transform_constraint_data array, spine_transform_constraint_data inValue) {
return ((Array<TransformConstraintData *>*)array)->contains((TransformConstraintData *)inValue);
}
int spine_array_transform_constraint_data_index_of(spine_array_transform_constraint_data array, spine_transform_constraint_data inValue) {
return ((Array<TransformConstraintData *>*)array)->indexOf((TransformConstraintData *)inValue);
}
spine_transform_constraint_data * spine_array_transform_constraint_data_buffer(spine_array_transform_constraint_data array) {
return (spine_transform_constraint_data *)((Array<TransformConstraintData *>*)array)->buffer();
}
spine_array_update spine_array_update_create(void) {
return (spine_array_update) new (__FILE__, __LINE__) Array<Update *>();
}

116
spine-c/src/generated/arrays.h
View File

@ -54,10 +54,7 @@ SPINE_OPAQUE_TYPE(spine_array_constraint_data)
SPINE_OPAQUE_TYPE(spine_array_event)
SPINE_OPAQUE_TYPE(spine_array_event_data)
SPINE_OPAQUE_TYPE(spine_array_from_property)
SPINE_OPAQUE_TYPE(spine_array_ik_constraint_data)
SPINE_OPAQUE_TYPE(spine_array_path_constraint_data)
SPINE_OPAQUE_TYPE(spine_array_physics_constraint)
SPINE_OPAQUE_TYPE(spine_array_physics_constraint_data)
SPINE_OPAQUE_TYPE(spine_array_polygon)
SPINE_OPAQUE_TYPE(spine_array_skin)
SPINE_OPAQUE_TYPE(spine_array_slot)
@ -66,7 +63,6 @@ SPINE_OPAQUE_TYPE(spine_array_texture_region)
SPINE_OPAQUE_TYPE(spine_array_timeline)
SPINE_OPAQUE_TYPE(spine_array_to_property)
SPINE_OPAQUE_TYPE(spine_array_track_entry)
SPINE_OPAQUE_TYPE(spine_array_transform_constraint_data)
SPINE_OPAQUE_TYPE(spine_array_update)
SPINE_C_API spine_array_float spine_array_float_create(void);
@ -545,62 +541,6 @@ SPINE_C_API int spine_array_from_property_index_of(spine_array_from_property arr
SPINE_C_API spine_from_property * spine_array_from_property_buffer(spine_array_from_property array);
SPINE_C_API spine_array_ik_constraint_data spine_array_ik_constraint_data_create(void);
SPINE_C_API spine_array_ik_constraint_data spine_array_ik_constraint_data_create_with_capacity(size_t initialCapacity);
SPINE_C_API void spine_array_ik_constraint_data_dispose(spine_array_ik_constraint_data array);
SPINE_C_API void spine_array_ik_constraint_data_clear(spine_array_ik_constraint_data array);
SPINE_C_API size_t spine_array_ik_constraint_data_get_capacity(spine_array_ik_constraint_data array);
SPINE_C_API size_t spine_array_ik_constraint_data_size(spine_array_ik_constraint_data array);
SPINE_C_API spine_array_ik_constraint_data spine_array_ik_constraint_data_set_size(spine_array_ik_constraint_data array, size_t newSize, spine_ik_constraint_data defaultValue);
SPINE_C_API void spine_array_ik_constraint_data_ensure_capacity(spine_array_ik_constraint_data array, size_t newCapacity);
SPINE_C_API void spine_array_ik_constraint_data_add(spine_array_ik_constraint_data array, spine_ik_constraint_data inValue);
SPINE_C_API void spine_array_ik_constraint_data_add_all(spine_array_ik_constraint_data array, spine_array_ik_constraint_data inValue);
SPINE_C_API void spine_array_ik_constraint_data_clear_and_add_all(spine_array_ik_constraint_data array, spine_array_ik_constraint_data inValue);
SPINE_C_API void spine_array_ik_constraint_data_remove_at(spine_array_ik_constraint_data array, size_t inIndex);
SPINE_C_API bool spine_array_ik_constraint_data_contains(spine_array_ik_constraint_data array, spine_ik_constraint_data inValue);
SPINE_C_API int spine_array_ik_constraint_data_index_of(spine_array_ik_constraint_data array, spine_ik_constraint_data inValue);
SPINE_C_API spine_ik_constraint_data * spine_array_ik_constraint_data_buffer(spine_array_ik_constraint_data array);
SPINE_C_API spine_array_path_constraint_data spine_array_path_constraint_data_create(void);
SPINE_C_API spine_array_path_constraint_data spine_array_path_constraint_data_create_with_capacity(size_t initialCapacity);
SPINE_C_API void spine_array_path_constraint_data_dispose(spine_array_path_constraint_data array);
SPINE_C_API void spine_array_path_constraint_data_clear(spine_array_path_constraint_data array);
SPINE_C_API size_t spine_array_path_constraint_data_get_capacity(spine_array_path_constraint_data array);
SPINE_C_API size_t spine_array_path_constraint_data_size(spine_array_path_constraint_data array);
SPINE_C_API spine_array_path_constraint_data spine_array_path_constraint_data_set_size(spine_array_path_constraint_data array, size_t newSize, spine_path_constraint_data defaultValue);
SPINE_C_API void spine_array_path_constraint_data_ensure_capacity(spine_array_path_constraint_data array, size_t newCapacity);
SPINE_C_API void spine_array_path_constraint_data_add(spine_array_path_constraint_data array, spine_path_constraint_data inValue);
SPINE_C_API void spine_array_path_constraint_data_add_all(spine_array_path_constraint_data array, spine_array_path_constraint_data inValue);
SPINE_C_API void spine_array_path_constraint_data_clear_and_add_all(spine_array_path_constraint_data array, spine_array_path_constraint_data inValue);
SPINE_C_API void spine_array_path_constraint_data_remove_at(spine_array_path_constraint_data array, size_t inIndex);
SPINE_C_API bool spine_array_path_constraint_data_contains(spine_array_path_constraint_data array, spine_path_constraint_data inValue);
SPINE_C_API int spine_array_path_constraint_data_index_of(spine_array_path_constraint_data array, spine_path_constraint_data inValue);
SPINE_C_API spine_path_constraint_data * spine_array_path_constraint_data_buffer(spine_array_path_constraint_data array);
SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_create(void);
SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_create_with_capacity(size_t initialCapacity);
@ -629,34 +569,6 @@ SPINE_C_API int spine_array_physics_constraint_index_of(spine_array_physics_cons
SPINE_C_API spine_physics_constraint * spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
SPINE_C_API spine_array_physics_constraint_data spine_array_physics_constraint_data_create(void);
SPINE_C_API spine_array_physics_constraint_data spine_array_physics_constraint_data_create_with_capacity(size_t initialCapacity);
SPINE_C_API void spine_array_physics_constraint_data_dispose(spine_array_physics_constraint_data array);
SPINE_C_API void spine_array_physics_constraint_data_clear(spine_array_physics_constraint_data array);
SPINE_C_API size_t spine_array_physics_constraint_data_get_capacity(spine_array_physics_constraint_data array);
SPINE_C_API size_t spine_array_physics_constraint_data_size(spine_array_physics_constraint_data array);
SPINE_C_API spine_array_physics_constraint_data spine_array_physics_constraint_data_set_size(spine_array_physics_constraint_data array, size_t newSize, spine_physics_constraint_data defaultValue);
SPINE_C_API void spine_array_physics_constraint_data_ensure_capacity(spine_array_physics_constraint_data array, size_t newCapacity);
SPINE_C_API void spine_array_physics_constraint_data_add(spine_array_physics_constraint_data array, spine_physics_constraint_data inValue);
SPINE_C_API void spine_array_physics_constraint_data_add_all(spine_array_physics_constraint_data array, spine_array_physics_constraint_data inValue);
SPINE_C_API void spine_array_physics_constraint_data_clear_and_add_all(spine_array_physics_constraint_data array, spine_array_physics_constraint_data inValue);
SPINE_C_API void spine_array_physics_constraint_data_remove_at(spine_array_physics_constraint_data array, size_t inIndex);
SPINE_C_API bool spine_array_physics_constraint_data_contains(spine_array_physics_constraint_data array, spine_physics_constraint_data inValue);
SPINE_C_API int spine_array_physics_constraint_data_index_of(spine_array_physics_constraint_data array, spine_physics_constraint_data inValue);
SPINE_C_API spine_physics_constraint_data * spine_array_physics_constraint_data_buffer(spine_array_physics_constraint_data array);
SPINE_C_API spine_array_polygon spine_array_polygon_create(void);
SPINE_C_API spine_array_polygon spine_array_polygon_create_with_capacity(size_t initialCapacity);
@ -881,34 +793,6 @@ SPINE_C_API int spine_array_track_entry_index_of(spine_array_track_entry array,
SPINE_C_API spine_track_entry * spine_array_track_entry_buffer(spine_array_track_entry array);
SPINE_C_API spine_array_transform_constraint_data spine_array_transform_constraint_data_create(void);
SPINE_C_API spine_array_transform_constraint_data spine_array_transform_constraint_data_create_with_capacity(size_t initialCapacity);
SPINE_C_API void spine_array_transform_constraint_data_dispose(spine_array_transform_constraint_data array);
SPINE_C_API void spine_array_transform_constraint_data_clear(spine_array_transform_constraint_data array);
SPINE_C_API size_t spine_array_transform_constraint_data_get_capacity(spine_array_transform_constraint_data array);
SPINE_C_API size_t spine_array_transform_constraint_data_size(spine_array_transform_constraint_data array);
SPINE_C_API spine_array_transform_constraint_data spine_array_transform_constraint_data_set_size(spine_array_transform_constraint_data array, size_t newSize, spine_transform_constraint_data defaultValue);
SPINE_C_API void spine_array_transform_constraint_data_ensure_capacity(spine_array_transform_constraint_data array, size_t newCapacity);
SPINE_C_API void spine_array_transform_constraint_data_add(spine_array_transform_constraint_data array, spine_transform_constraint_data inValue);
SPINE_C_API void spine_array_transform_constraint_data_add_all(spine_array_transform_constraint_data array, spine_array_transform_constraint_data inValue);
SPINE_C_API void spine_array_transform_constraint_data_clear_and_add_all(spine_array_transform_constraint_data array, spine_array_transform_constraint_data inValue);
SPINE_C_API void spine_array_transform_constraint_data_remove_at(spine_array_transform_constraint_data array, size_t inIndex);
SPINE_C_API bool spine_array_transform_constraint_data_contains(spine_array_transform_constraint_data array, spine_transform_constraint_data inValue);
SPINE_C_API int spine_array_transform_constraint_data_index_of(spine_array_transform_constraint_data array, spine_transform_constraint_data inValue);
SPINE_C_API spine_transform_constraint_data * spine_array_transform_constraint_data_buffer(spine_array_transform_constraint_data array);
SPINE_C_API spine_array_update spine_array_update_create(void);
SPINE_C_API spine_array_update spine_array_update_create_with_capacity(size_t initialCapacity);

32
spine-c/src/generated/skeleton_data.cpp
View File

@ -31,22 +31,6 @@ spine_animation spine_skeleton_data_find_animation(spine_skeleton_data self, con
return (spine_animation)((SkeletonData*)self)->findAnimation(String(animationName));
}
spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data self, const char* constraintName) {
return (spine_ik_constraint_data)((SkeletonData*)self)->findIkConstraint(String(constraintName));
}
spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(spine_skeleton_data self, const char* constraintName) {
return (spine_transform_constraint_data)((SkeletonData*)self)->findTransformConstraint(String(constraintName));
}
spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skeleton_data self, const char* constraintName) {
return (spine_path_constraint_data)((SkeletonData*)self)->findPathConstraint(String(constraintName));
}
spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data self, const char* constraintName) {
return (spine_physics_constraint_data)((SkeletonData*)self)->findPhysicsConstraint(String(constraintName));
}
const char* spine_skeleton_data_get_name(spine_skeleton_data self) {
return (const char*)&((SkeletonData*)self)->getName();
}
@ -83,22 +67,6 @@ spine_array_animation spine_skeleton_data_get_animations(spine_skeleton_data sel
return (spine_array_animation)&((SkeletonData*)self)->getAnimations();
}
spine_array_ik_constraint_data spine_skeleton_data_get_ik_constraints(spine_skeleton_data self) {
return (spine_array_ik_constraint_data)&((SkeletonData*)self)->getIkConstraints();
}
spine_array_transform_constraint_data spine_skeleton_data_get_transform_constraints(spine_skeleton_data self) {
return (spine_array_transform_constraint_data)&((SkeletonData*)self)->getTransformConstraints();
}
spine_array_path_constraint_data spine_skeleton_data_get_path_constraints(spine_skeleton_data self) {
return (spine_array_path_constraint_data)&((SkeletonData*)self)->getPathConstraints();
}
spine_array_physics_constraint_data spine_skeleton_data_get_physics_constraints(spine_skeleton_data self) {
return (spine_array_physics_constraint_data)&((SkeletonData*)self)->getPhysicsConstraints();
}
spine_array_constraint_data spine_skeleton_data_get_constraints(spine_skeleton_data self) {
return (spine_array_constraint_data)&((SkeletonData*)self)->getConstraints();
}

8
spine-c/src/generated/skeleton_data.h
View File

@ -17,10 +17,6 @@ SPINE_C_API spine_slot_data spine_skeleton_data_find_slot(spine_skeleton_data se
SPINE_C_API spine_skin spine_skeleton_data_find_skin(spine_skeleton_data self, const char* skinName);
SPINE_C_API spine_event_data spine_skeleton_data_find_event(spine_skeleton_data self, const char* eventDataName);
SPINE_C_API spine_animation spine_skeleton_data_find_animation(spine_skeleton_data self, const char* animationName);
SPINE_C_API spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data self, const char* constraintName);
SPINE_C_API spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(spine_skeleton_data self, const char* constraintName);
SPINE_C_API spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skeleton_data self, const char* constraintName);
SPINE_C_API spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data self, const char* constraintName);
SPINE_C_API const char* spine_skeleton_data_get_name(spine_skeleton_data self);
SPINE_C_API void spine_skeleton_data_set_name(spine_skeleton_data self, const char* inValue);
SPINE_C_API spine_array_bone_data spine_skeleton_data_get_bones(spine_skeleton_data self);
@ -30,10 +26,6 @@ SPINE_C_API spine_skin spine_skeleton_data_get_default_skin(spine_skeleton_data
SPINE_C_API void spine_skeleton_data_set_default_skin(spine_skeleton_data self, spine_skin inValue);
SPINE_C_API spine_array_event_data spine_skeleton_data_get_events(spine_skeleton_data self);
SPINE_C_API spine_array_animation spine_skeleton_data_get_animations(spine_skeleton_data self);
SPINE_C_API spine_array_ik_constraint_data spine_skeleton_data_get_ik_constraints(spine_skeleton_data self);
SPINE_C_API spine_array_transform_constraint_data spine_skeleton_data_get_transform_constraints(spine_skeleton_data self);
SPINE_C_API spine_array_path_constraint_data spine_skeleton_data_get_path_constraints(spine_skeleton_data self);
SPINE_C_API spine_array_physics_constraint_data spine_skeleton_data_get_physics_constraints(spine_skeleton_data self);
SPINE_C_API spine_array_constraint_data spine_skeleton_data_get_constraints(spine_skeleton_data self);
SPINE_C_API float spine_skeleton_data_get_x(spine_skeleton_data self);
SPINE_C_API void spine_skeleton_data_set_x(spine_skeleton_data self, float inValue);

2
spine-cpp/spine-cpp/include/spine/SkeletonBinary.h
View File

@ -138,7 +138,7 @@ namespace spine {
DataInput(SkeletonData *skeletonData, const unsigned char *data, size_t length) : cursor(data), end(data + length), skeletonData(skeletonData) {}
inline int read() {
return readByte();
return readUnsignedByte();
}
inline signed char readByte() {

24
spine-cpp/spine-cpp/include/spine/SkeletonData.h
View File

@ -88,18 +88,6 @@ namespace spine {
/// @return May be NULL.
Animation *findAnimation(const String &animationName);
/// @return May be NULL.
IkConstraintData *findIkConstraint(const String &constraintName);
/// @return May be NULL.
TransformConstraintData *findTransformConstraint(const String &constraintName);
/// @return May be NULL.
PathConstraintData *findPathConstraint(const String &constraintName);
/// @return May be NULL.
PhysicsConstraintData *findPhysicsConstraint(const String &constraintName);
/// The skeleton's name, which by default is the name of the skeleton data file when possible, or null when a name hasn't been
/// set.
const String &getName();
@ -128,14 +116,6 @@ namespace spine {
/// The skeleton's animations.
Array<Animation *> &getAnimations();
Array<IkConstraintData *> &getIkConstraints();
Array<TransformConstraintData *> &getTransformConstraints();
Array<PathConstraintData *> &getPathConstraints();
Array<PhysicsConstraintData *> &getPhysicsConstraints();
/// The skeleton's constraints.
Array<ConstraintData *> &getConstraints();
@ -212,10 +192,6 @@ namespace spine {
Skin *_defaultSkin;
Array<EventData *> _events;
Array<Animation *> _animations;
Array<IkConstraintData *> _ikConstraints;
Array<TransformConstraintData *> _transformConstraints;
Array<PathConstraintData *> _pathConstraints;
Array<PhysicsConstraintData *> _physicsConstraints;
Array<ConstraintData *> _constraints;
float _x, _y, _width, _height;
float _referenceScale;

53
spine-cpp/spine-cpp/src/spine/SkeletonData.cpp
View File

@ -67,12 +67,7 @@ SkeletonData::~SkeletonData() {
ArrayUtils::deleteElements(_events);
ArrayUtils::deleteElements(_animations);
ArrayUtils::deleteElements(_ikConstraints);
ArrayUtils::deleteElements(_transformConstraints);
ArrayUtils::deleteElements(_pathConstraints);
ArrayUtils::deleteElements(_physicsConstraints);
// Note: _constraints contains pointers to objects already cleaned up above, so just clear
_constraints.clear();
ArrayUtils::deleteElements(_constraints);
for (size_t i = 0; i < _strings.size(); i++) {
SpineExtension::free(_strings[i], __FILE__, __LINE__);
}
@ -98,22 +93,6 @@ Animation *SkeletonData::findAnimation(const String &animationName) {
return ArrayUtils::findWithName(_animations, animationName);
}
IkConstraintData *SkeletonData::findIkConstraint(const String &constraintName) {
return ArrayUtils::findWithName(_ikConstraints, constraintName);
}
TransformConstraintData *SkeletonData::findTransformConstraint(const String &constraintName) {
return ArrayUtils::findWithName(_transformConstraints, constraintName);
}
PathConstraintData *SkeletonData::findPathConstraint(const String &constraintName) {
return ArrayUtils::findWithName(_pathConstraints, constraintName);
}
PhysicsConstraintData *SkeletonData::findPhysicsConstraint(const String &constraintName) {
return ArrayUtils::findWithName(_physicsConstraints, constraintName);
}
const String &SkeletonData::getName() {
return _name;
}
@ -150,22 +129,6 @@ Array<Animation *> &SkeletonData::getAnimations() {
return _animations;
}
Array<IkConstraintData *> &SkeletonData::getIkConstraints() {
return _ikConstraints;
}
Array<TransformConstraintData *> &SkeletonData::getTransformConstraints() {
return _transformConstraints;
}
Array<PathConstraintData *> &SkeletonData::getPathConstraints() {
return _pathConstraints;
}
Array<PhysicsConstraintData *> &SkeletonData::getPhysicsConstraints() {
return _physicsConstraints;
}
float SkeletonData::getX() {
return _x;
}
@ -248,19 +211,5 @@ void SkeletonData::setFps(float inValue) {
}
Array<ConstraintData *> &SkeletonData::getConstraints() {
// Build unified constraints array by aggregating all constraint types
_constraints.clear();
for (size_t i = 0, n = _ikConstraints.size(); i < n; i++) {
_constraints.add(static_cast<ConstraintData *>(_ikConstraints[i]));
}
for (size_t i = 0, n = _transformConstraints.size(); i < n; i++) {
_constraints.add(static_cast<ConstraintData *>(_transformConstraints[i]));
}
for (size_t i = 0, n = _pathConstraints.size(); i < n; i++) {
_constraints.add(static_cast<ConstraintData *>(_pathConstraints[i]));
}
for (size_t i = 0, n = _physicsConstraints.size(); i < n; i++) {
_constraints.add(static_cast<ConstraintData *>(_physicsConstraints[i]));
}
return _constraints;
}

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

@ -295,7 +295,6 @@ SkeletonData *SkeletonJson::readSkeletonData(const char *json) {
setup._compress = Json::getBoolean(constraintMap, "compress", false);
setup._stretch = Json::getBoolean(constraintMap, "stretch", false);
skeletonData->_ikConstraints.add(data);
skeletonData->_constraints.add(data);
} else if (strcmp(type, "transform") == 0) {
TransformConstraintData *data = new (__FILE__, __LINE__) TransformConstraintData(name);
@ -384,7 +383,6 @@ SkeletonData *SkeletonJson::readSkeletonData(const char *json) {
if (scaleY) setup._mixScaleY = Json::getFloat(constraintMap, "mixScaleY", setup._mixScaleX);
if (shearY) setup._mixShearY = Json::getFloat(constraintMap, "mixShearY", 1);
skeletonData->_transformConstraints.add(data);
skeletonData->_constraints.add(data);
} else if (strcmp(type, "path") == 0) {
PathConstraintData *data = new (__FILE__, __LINE__) PathConstraintData(name);
@ -416,7 +414,6 @@ SkeletonData *SkeletonJson::readSkeletonData(const char *json) {
setup._mixX = Json::getFloat(constraintMap, "mixX", 1);
setup._mixY = Json::getFloat(constraintMap, "mixY", setup._mixX);
skeletonData->_pathConstraints.add(data);
skeletonData->_constraints.add(data);
} else if (strcmp(type, "physics") == 0) {
PhysicsConstraintData *data = new (__FILE__, __LINE__) PhysicsConstraintData(name);
@ -449,7 +446,6 @@ SkeletonData *SkeletonJson::readSkeletonData(const char *json) {
data->_gravityGlobal = Json::getBoolean(constraintMap, "gravityGlobal", false);
data->_mixGlobal = Json::getBoolean(constraintMap, "mixGlobal", false);
skeletonData->_physicsConstraints.add(data);
skeletonData->_constraints.add(data);
} else if (strcmp(type, "slider") == 0) {
SliderData *data = new (__FILE__, __LINE__) SliderData(name);
@ -1029,12 +1025,12 @@ Animation *SkeletonJson::readAnimation(Json *map, SkeletonData *skeletonData) {
for (Json *timelineMap = Json::getItem(map, "ik") ? Json::getItem(map, "ik")->_child : NULL; timelineMap; timelineMap = timelineMap->_next) {
Json *keyMap = timelineMap->_child;
if (keyMap == NULL) continue;
IkConstraintData *constraint = skeletonData->findIkConstraint(timelineMap->_name);
IkConstraintData *constraint = skeletonData->findConstraint<IkConstraintData>(timelineMap->_name);
if (!constraint) {
ArrayUtils::deleteElements(timelines);
return NULL;
}
int constraintIndex = skeletonData->_ikConstraints.indexOf(constraint);
int constraintIndex = skeletonData->_constraints.indexOf(constraint);
IkConstraintTimeline *timeline = new (__FILE__, __LINE__) IkConstraintTimeline(timelineMap->_size,
timelineMap->_size << 1,
constraintIndex);
@ -1069,12 +1065,12 @@ Animation *SkeletonJson::readAnimation(Json *map, SkeletonData *skeletonData) {
for (Json *timelineMap = Json::getItem(map, "transform") ? Json::getItem(map, "transform")->_child : NULL; timelineMap; timelineMap = timelineMap->_next) {
Json *keyMap = timelineMap->_child;
if (keyMap == NULL) continue;
TransformConstraintData *constraint = skeletonData->findTransformConstraint(timelineMap->_name);
TransformConstraintData *constraint = skeletonData->findConstraint<TransformConstraintData>(timelineMap->_name);
if (!constraint) {
ArrayUtils::deleteElements(timelines);
return NULL;
}
int constraintIndex = skeletonData->_transformConstraints.indexOf(constraint);
int constraintIndex = skeletonData->_constraints.indexOf(constraint);
TransformConstraintTimeline *timeline = new (__FILE__, __LINE__) TransformConstraintTimeline(
timelineMap->_size, timelineMap->_size * 6, constraintIndex);
float time = Json::getFloat(keyMap, "time", 0);
@ -1118,12 +1114,12 @@ Animation *SkeletonJson::readAnimation(Json *map, SkeletonData *skeletonData) {
// Path constraint timelines.
for (Json *constraintMap = Json::getItem(map, "path") ? Json::getItem(map, "path")->_child : NULL; constraintMap; constraintMap = constraintMap->_next) {
PathConstraintData *constraint = skeletonData->findPathConstraint(constraintMap->_name);
PathConstraintData *constraint = skeletonData->findConstraint<PathConstraintData>(constraintMap->_name);
if (!constraint) {
ArrayUtils::deleteElements(timelines);
return NULL;
}
int index = skeletonData->_pathConstraints.indexOf(constraint);
int index = skeletonData->_constraints.indexOf(constraint);
for (Json *timelineMap = constraintMap->_child; timelineMap; timelineMap = timelineMap->_next) {
Json *keyMap = timelineMap->_child;
if (keyMap == NULL) continue;
@ -1184,7 +1180,7 @@ Animation *SkeletonJson::readAnimation(Json *map, SkeletonData *skeletonData) {
ArrayUtils::deleteElements(timelines);
return NULL;
}
index = skeletonData->_physicsConstraints.indexOf(constraint);
index = skeletonData->_constraints.indexOf(constraint);
}
for (Json *timelineMap = constraintMap->_child; timelineMap; timelineMap = timelineMap->_next) {
Json *keyMap = timelineMap->_child;